„Kubernetes“ mokymo programos 1 dalis: programos, mikropaslaugos ir talpyklos

Mūsų prašymu Habras sukūrė centrą Kubernetes ir džiaugiamės galėdami joje patalpinti pirmąjį leidinį. Prenumeruoti!

Kubernetes yra lengva. Kodėl bankai man moka didelius pinigus už darbą šioje srityje, o bet kas gali įsisavinti šią technologiją vos per kelias valandas?

Jei abejojate, kad Kubernetes taip greitai galima išmokti, siūlau pabandyti tai padaryti patiems. Būtent, įsisavinę šią medžiagą, galėsite paleisti programą, pagrįstą mikropaslaugomis Kubernetes klasteryje. Galiu tai garantuoti, nes būtent ta pačia metodika, kurią naudoju čia, mokau mūsų klientus dirbti su Kubernetes. Kuo šis vadovas skiriasi nuo kitų? Tiesą sakant, daug dalykų. Taigi, dauguma šios medžiagos prasideda paprastų dalykų paaiškinimu - Kubernetes sąvokomis ir komandos kubectl ypatybėmis. Šių straipsnių autoriai mano, kad jų skaitytojas yra susipažinęs su programų kūrimu, mikropaslaugomis ir Docker konteineriais. Mes eisime kitu keliu. Pirmiausia pakalbėkime apie tai, kaip kompiuteryje paleisti programą, pagrįstą mikropaslaugomis. Tada pažvelgsime į kiekvienos mikropaslaugos konteinerių vaizdų kūrimą. O po to susipažinsime su Kubernetes ir analizuosime mikropaslaugomis pagrįstos aplikacijos diegimą Kubernetes valdomame klasteryje.

Šis požiūris, laipsniškas požiūris į Kubernetes, suteiks supratimo apie tai, kas vyksta, gilumą, kurio reikia paprastam žmogui, kad suprastų, kaip paprastai viskas yra išdėstyta Kubernetes. „Kubernetes“ tikrai yra paprasta technologija, su sąlyga, kad kas nori ją įvaldyti, žino, kur ir kaip ji naudojama.

Dabar, nieko nelaukdami, pradėkime dirbti ir pakalbėkime apie programą, su kuria dirbsime.

Eksperimentinė programėlė

Mūsų programa atliks tik vieną funkciją. Kaip įvestis paima vieną sakinį, po kurio, naudodamas teksto analizės priemones, atlieka šio sakinio sentimentų analizę, gaudamas sakinio autoriaus emocinio požiūrio į tam tikrą objektą įvertinimą.

Taip atrodo pagrindinis šios programos langas.

Sentimentų analizės žiniatinklio programa

Techniniu požiūriu programą sudaro trys mikropaslaugos, kurių kiekviena išsprendžia tam tikrą užduočių rinkinį:

• „SA-Frontend“ yra „Nginx“ žiniatinklio serveris, aptarnaujantis statinius „React“ failus.
• SA-WebApp yra žiniatinklio programa, parašyta Java kalba, kuri apdoroja užklausas iš sąsajos.
• SA-Logic yra Python programa, kuri atlieka teksto nuotaikų analizę.

Svarbu pažymėti, kad mikropaslaugos neegzistuoja atskirai. Jie įgyvendina „pareigų atskyrimo“ idėją, tačiau tuo pat metu jiems reikia bendrauti tarpusavyje.

Duomenų srautai programoje

Aukščiau pateiktoje diagramoje galite matyti sunumeruotus sistemos etapus, iliustruojančius duomenų srautus programoje. Išskaidykime juos:

1. Naršyklė prašo failo iš serverio index.html (o tai savo ruožtu įkelia programos „React“ paketą).
2. Vartotojas sąveikauja su programa, todėl iškviečiama žiniatinklio programa, pagrįsta pavasariu.
3. Žiniatinklio programa persiunčia užklausą išanalizuoti tekstą į Python programą.
4. „Python“ programa analizuoja teksto nuotaikas ir pateikia rezultatą kaip atsakymą į užklausą.
5. „Spring“ programa siunčia atsakymą „React“ programai (kuri, savo ruožtu, vartotojui parodo analizuoto teksto rezultatą).

Visų šių programų kodą galima rasti čia. Rekomenduoju jau dabar nukopijuoti šią saugyklą sau, nes mūsų laukia daug įdomių eksperimentų.

Vietiniame kompiuteryje paleidžiama programa, pagrįsta mikro paslaugomis

Kad programa veiktų, turime paleisti visas tris mikro paslaugas. Pradėkime nuo gražiausio iš jų – priekinės programos.

▍„React“ nustatymas vietinei plėtrai

Norėdami paleisti React programą, kompiuteryje turite įdiegti Node.js sistemą ir NPM. Įdiegę visa tai, naudodami terminalą eikite į projekto aplanką sa-frontend ir paleiskite šią komandą:

npm install

Vykdydami šią komandą aplanke node_modules bus įkeliamos React programos priklausomybės, kurių įrašai yra faile package.json. Atsisiuntę priklausomybes tame pačiame aplanke, paleiskite šią komandą:

npm start

Tai viskas. „React“ programa dabar veikia ir ją galima pasiekti nuėję į naršyklės adresą localhost:3000. Galite ką nors pakeisti jo kode. Naršyklėje iš karto pamatysite šių pakeitimų poveikį. Tai įmanoma dėl vadinamojo „karštojo“ modulių pakeitimo. Dėl to priekinės dalies kūrimas virsta paprasta ir malonia patirtimi.

▍React programos paruošimas gamybai

Norėdami iš tikrųjų naudoti „React“ programą, turime ją konvertuoti į statinių failų rinkinį ir pateikti juos klientams naudojant žiniatinklio serverį.

Norėdami sukurti programą „React“, dar kartą naudodami terminalą, eikite į aplanką sa-frontend ir paleiskite šią komandą:

npm run build

Taip projekto aplanke bus sukurtas katalogas build. Jame bus visi statiniai failai, reikalingi, kad programa „React“ veiktų.

▍Statinių failų aptarnavimas naudojant „Nginx“.

Pirmiausia turite įdiegti ir paleisti „Nginx“ žiniatinklio serverį. Čia galite jį atsisiųsti ir rasti instrukcijas, kaip ją įdiegti ir paleisti. Tada turite nukopijuoti aplanko turinį sa-frontend/build į aplanką [your_nginx_installation_dir]/html.

Taikant šį metodą, failas, sugeneruotas surenkant programą „React“. index.html bus galima rasti adresu [your_nginx_installation_dir]/html/index.html. Tai yra failas, kurį pagal numatytuosius nustatymus „Nginx“ serveris išduoda, kai jį pasiekia. Serveris sukonfigūruotas klausytis prievado 80, bet galite tinkinti jį taip, kaip norite, redaguodami failą [your_nginx_installation_dir]/conf/nginx.conf.

Dabar atidarykite naršyklę ir eikite į localhost:80. Pamatysite programos „React“ puslapį.

„React“ programa, kurią aptarnauja „Nginx“ serveris

Jei dabar ką nors įvesite į lauką Type your sentence ir paspauskite mygtuką Send - nieko nebus. Bet jei pažvelgsite į konsolę, galite pamatyti klaidų pranešimus. Norėdami tiksliai suprasti, kur atsiranda šios klaidos, išanalizuokime programos kodą.

▍Priešinės programos kodo analizė

Žiūrint į failo kodą App.js, matome, kad spustelėję mygtuką Send vadina metodu analyzeSentence(). Šio metodo kodas parodytas žemiau. Tuo pat metu atkreipkite dėmesį į tai, kad kiekvienoje eilutėje, kuriai yra formos komentaras # Номер, po kodu pateikiamas paaiškinimas. Tokiu pat būdu analizuosime kitus kodo fragmentus.

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, kuriam pateikiama POST užklausa. Manoma, kad šis adresas yra programa, laukianti tokių užklausų.

2.Prašymo įstaiga išsiųsta į paraišką. Štai užklausos turinio pavyzdys:

{
    sentence: "I like yogobella!"
}

3.Kai gaunamas atsakymas į užklausą, komponento būsena atnaujinama. Dėl to komponentas iš naujo pateikiamas. Jei gauname duomenis (ty JSON objektą, kuriame yra įvesti duomenys ir apskaičiuotas teksto balas), išvesime komponentą Polaritytol, kol bus įvykdytos sąlygos. Štai kaip aprašome komponentą:

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

Atrodo, kad kodas veikia gana gerai. Kas čia vis dėlto negerai? Jei manote, kad adresu, kuriuo programa bando siųsti POST užklausą, dar nėra nieko, galinčio priimti ir apdoroti šią užklausą, būsite visiškai teisūs. Būtent, apdoroti prašymus, ateinančius adresu http://localhost:8080/sentiment, turime paleisti žiniatinklio programą, pagrįstą pavasariu.

Mums reikia pavasario programos, kuri galėtų priimti POST užklausą

▍Žiniatinklio programos nustatymas remiantis pavasariu

Norint įdiegti „Spring“ programą, jums reikia JDK8 ir Maven bei tinkamai sukonfigūruotų aplinkos kintamųjų. Įdiegę visa tai, galėsite tęsti darbą su mūsų projektu.

▍Programos supakavimas į jar failą

Naudodami terminalą eikite į aplanką sa-webapp ir įveskite šią komandą:

mvn install

Įvykdę šią komandą aplanke sa-webapp bus sukurtas katalogas target. Čia bus „Java“ programa, supakuota į jar failą, kurį reprezentuos failas sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Java programos paleidimas

Eikite į aplanką target ir paleiskite programą naudodami šią komandą:

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

Vykdant šią komandą įvyks klaida. Norėdami pradėti taisyti, galime išanalizuoti išsamią išimties informaciją kamino sekimo duomenyse:

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

Mums čia svarbiausia paminėjimas, kad neįmanoma išsiaiškinti prasmės sa.logic.api.url. Išanalizuokime kodą, kuriame įvyko klaida.

▍Java programos kodo analizė

Čia yra kodo fragmentas, kuriame įvyko klaida.

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

1. SentimentController yra laukas saLogicApiUrl. Jo vertę nustato turtas sa.logic.api.url.
2. Linija saLogicApiUrl susijungia su verte /analyse/sentiment. Kartu jie sudaro adresą, kuriuo galima skambinti į teksto analizę atliekančią mikroservisą.

▍Nustatyti nuosavybės vertę

Pavasarį numatytasis nuosavybės verčių šaltinis yra failas application.properties, kurį galite rasti adresu sa-webapp/src/main/resources. Tačiau jo naudojimas nėra vienintelis nuosavybės verčių nustatymo būdas. Taip pat galite tai padaryti naudodami šią komandą:

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

Šios nuosavybės vertė turėtų nurodyti mūsų Python programos adresą.

Jį sukonfigūruodami nurodome „Spring“ žiniatinklio programai, kur ji turi eiti, kad įvykdytų teksto analizės užklausas.

Kad neapsunkintume savo gyvenimo, nuspręsime, kad Python aplikacija bus pasiekiama adresu localhost:5000 ir stenkitės to nepamiršti. Dėl to komanda paleisti „Spring“ programą atrodys taip:

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

Mūsų sistemoje trūksta Python programos

Dabar tereikia paleisti Python programą ir sistema veiks taip, kaip tikėtasi.

▍Python programos nustatymas

Kad galėtumėte paleisti „Python“ programą, turite įdiegti „Python 3“ ir „Pip“ bei tinkamai nustatyti atitinkamus aplinkos kintamuosius.

▍Įdiekite priklausomybes

Eikite į projekto aplanką sa-logic/sa ir paleiskite šias komandas:

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

▍Programos paleidimas

Įdiegę priklausomybes, esame pasirengę paleisti programą:

python sentiment_analysis.py

Įvykdžius šią komandą, mums bus pasakyta:

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

Tai reiškia, kad programa veikia ir laukia užklausų adresu localhost:5000/

▍Kodo tyrimas

Pažvelkime į Python programos kodą, kad suprastume, kaip jis reaguoja į užklausas:

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. Objekto inicijavimas Flask.
2. Nurodykite adresą, kuriuo reikia pateikti POST užklausas.
3. Turto atgavimas sentence iš užklausos institucijos.
4. Anoniminio objekto inicijavimas TextBlob ir gauti vertę polarity už pirmą pasiūlymą, gautą užklausos tekste (mūsų atveju tai vienintelis pasiūlymas pateiktas analizei).
5. Grąžina atsakymą, kurio turinyje yra pasiūlymo tekstas ir jam apskaičiuotas rodiklis polarity.
6. Paleidžiama programa „Flask“, kuri bus pasiekiama adresu 0.0.0.0:5000 (Ją taip pat galite pasiekti naudodami formos konstrukciją localhost:5000).

Dabar veikia mikropaslaugos, sudarančios programą. Jie yra pasirengę bendrauti vienas su kitu. Štai kaip atrodo taikymo schema šiame darbo etape.

Visos mikropaslaugos, kurios sudaro programą, yra sveikos

Dabar, prieš tęsdami, atidarykite programą „React“ naršyklėje ir pabandykite su ja išanalizuoti kokį nors sakinį. Jei viskas padaryta teisingai – paspaudus mygtuką Send analizės rezultatus matysite po teksto laukeliu.

Kitame skyriuje kalbėsime apie tai, kaip paleisti savo mikropaslaugas Docker konteineriuose. Tai būtina norint paruošti programą veikti Kubernetes klasteryje.

Dokerių konteineriai

Kubernetes yra konteinerinių programų diegimo, mastelio keitimo ir valdymo automatizavimo sistema. Jis taip pat vadinamas "konteinerių orkestru". Jei Kubernetes veikia su konteineriais, prieš naudodami šią sistemą pirmiausia turime įsigyti šiuos konteinerius. Bet pirmiausia pakalbėkime apie tai, kas yra konteineriai. Bene geriausią atsakymą į klausimą, kas tai yra, galima rasti dokumentacija į Docker:

Konteinerio vaizdas yra lengvas, savarankiškas, vykdomasis paketas, kuriame yra programa, kurioje yra viskas, ko reikia jai paleisti: programos kodas, vykdymo aplinka, sistemos įrankiai ir bibliotekos, nustatymai. Konteinerių programos gali būti naudojamos tiek Linux, tiek Windows aplinkoje ir visada veiks taip pat, nepaisant infrastruktūros.

Tai reiškia, kad konteinerius galima paleisti bet kuriame kompiuteryje, įskaitant gamybos serverius, ir bet kokioje aplinkoje juose esančios programos veiks taip pat.

Norėdami ištirti konteinerių funkcijas ir palyginti jas su kitais programų paleidimo būdais, pažvelkime į „React“ programos aptarnavimo naudojant virtualią mašiną ir konteinerį pavyzdį.

▍Statinių React programos failų aptarnavimas naudojant virtualią mašiną

Bandydami organizuoti statinių failų priežiūrą naudodami virtualias mašinas, susidursime su šiais trūkumais:

1. Neefektyvus išteklių naudojimas, nes kiekviena virtuali mašina yra visa operacinė sistema.
2. Priklausomybė nuo platformos. Tai, kas veikia kai kuriuose vietiniuose kompiuteriuose, gali neveikti gamybos serveryje.
3. Lėtas ir daug išteklių reikalaujantis virtualios mašinos sprendimo mastelio keitimas.

„Nginx“ žiniatinklio serveris, aptarnaujantis statinius failus, veikiančius virtualioje mašinoje

Jei konteineriai naudojami panašiai problemai išspręsti, tada, palyginti su virtualiomis mašinomis, galima pastebėti šias stipriąsias puses:

1. Efektyvus išteklių naudojimas: dirbkite su operacine sistema naudodami „Docker“.
2. Platformos nepriklausomybė. Konteineris, kurį kūrėjas gali paleisti savo kompiuteryje, veiks bet kur.
3. Lengvas diegimas naudojant vaizdo sluoksnius.

„Nginx“ žiniatinklio serveris, aptarnaujantis statinius failus, veikiančius konteineryje

Palyginome virtualias mašinas ir konteinerius tik keletu punktų, tačiau net ir to pakanka, kad pajustume konteinerių privalumus. Čia Galite rasti išsamios informacijos apie „Docker“ konteinerius.

▍Sukurti React programos sudėtinio rodinio vaizdą

Pagrindinis „Docker“ konteinerio blokas yra failas Dockerfile. Šio failo pradžioje įrašomas pagrindinis konteinerio vaizdas, tada pridedama instrukcijų seka, nurodanti, kaip sukurti konteinerį, kuris atitiktų programos poreikius.

Prieš pradėdami dirbti su failu Dockerfile, prisiminkite, ką padarėme, kad paruoštume React programos failus įkelti į Nginx serverį:

1. React programos paketo kūrimas (npm run build).
2. Nginx serverio paleidimas.
3. Katalogo turinio kopijavimas build iš projekto aplanko sa-frontend į serverio aplanką nginx/html.

Žemiau galite pamatyti paraleles tarp konteinerio kūrimo ir aukščiau nurodytų veiksmų, atliekamų vietiniame kompiuteryje.

▍Docker failo paruošimas SA-Frontend programai

Instrukcijos, kurias reikia įtraukti Dockerfile taikymui SA-Frontend, susideda tik iš dviejų komandų. Faktas yra tas, kad „Nginx“ kūrimo komanda paruošė pagrindinį vaizdas Nginx, kurią naudosime kurdami savo įvaizdį. Štai du žingsniai, kuriuos turime apibūdinti:

1. Nginx vaizdą turite padaryti vaizdo pagrindu.
2. Aplanko turinys sa-frontend/build reikia nukopijuoti į vaizdo aplanką nginx/html.

Jei nuo šio aprašymo pereisime prie failo Dockerfile, tada jis atrodys taip:

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

Kaip matote, čia viskas labai paprasta, o failo turinys netgi pasirodo gana skaitomas ir suprantamas. Šis failas nurodo sistemai nufotografuoti nginx su viskuo, ką jau turi, ir nukopijuokite katalogo turinį build į katalogą nginx/html.

Čia jums gali kilti klausimas, kaip aš žinau, kur tiksliai nukopijuoti failus iš aplanko buildt.y. iš kur atsirado kelias /usr/share/nginx/html. Tiesą sakant, čia taip pat nėra nieko sudėtingo. Faktas yra tas, kad reikiamą informaciją galite rasti apibūdinimas vaizdas.

▍Surinkite vaizdą ir įkelkite jį į saugyklą

Kad galėtume dirbti su užbaigtu vaizdu, turime jį pateikti vaizdų saugyklai. Norėdami tai padaryti, naudosime nemokamą debesyje pagrįstą vaizdų prieglobos platformą „Docker Hub“. Šiame darbo etape turite atlikti šiuos veiksmus:

1. Įdiekite dokininkas.
2. Registruokitės Docker Hub svetainėje.
3. Prisijunkite prie savo paskyros terminale vykdydami šią komandą:

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

Dabar naudodami terminalą turite eiti į katalogą sa-frontend ir ten paleiskite šią komandą:

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

Čia ir toliau panašiose komandose $DOCKER_USER_ID turėtų būti pakeistas jūsų vartotojo vardu Docker Hub. Pavyzdžiui, ši komandos dalis gali atrodyti taip: rinormaloku/sentiment-analysis-frontend.

Tokiu atveju šią komandą galima sutrumpinti pašalinant iš jos -f Dockerfile, nes aplankas, kuriame vykdome šią komandą, jau turi šį failą.

Norėdami nusiųsti gatavą vaizdą į saugyklą, mums reikia šios komandos:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Baigę patikrinkite „Docker Hub“ saugyklų sąrašą ir sužinokite, ar vaizdas buvo sėkmingai perkeltas į debesies saugyklą.

▍ Konteinerio paleidimas

Dabar kiekvienas gali atsisiųsti ir paleisti vaizdą, žinomą kaip $DOCKER_USER_ID/sentiment-analysis-frontend. Norėdami tai padaryti, turite paleisti šią komandų seką:

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

Dabar konteineris veikia ir galime tęsti darbą kurdami kitus mums reikalingus vaizdus. Tačiau prieš tęsdami supraskime dizainą 80:80, kuris yra komandoje paleisti vaizdą ir gali atrodyti painus.

• Pirmas numeris 80 yra pagrindinio kompiuterio (ty vietinio kompiuterio) prievado numeris.
• Antras numeris 80 yra konteinerio uostas, į kurį turėtų būti peradresuojama užklausa.

Apsvarstykite toliau pateiktą iliustraciją.

Uosto persiuntimas

Sistema persiunčia užklausas iš prievado <hostPort> į uostą <containerPort>. Tai yra, prieiga prie uosto 80 kompiuteris nukreipiamas į prievadą 80 konteineris.

Nuo uosto 80 atidarytas vietiniame kompiuteryje, galite pasiekti programą iš šio kompiuterio adresu localhost:80. Jei jūsų sistema nepalaiko Docker, galite paleisti programą Docker virtualioje mašinoje, kurios adresas atrodys taip <docker-machine ip>:80. Norėdami sužinoti Docker virtualios mašinos IP adresą, galite naudoti komandą docker-machine ip.

Šiuo metu, kai sėkmingai paleistas priekinės programos sudėtinis rodinys, turėtumėte galėti atidaryti jo puslapį naršyklėje.

▍.dockerignore failą

Programos vaizdo kūrimas SA-Frontend, galime pastebėti, kad šis procesas yra labai lėtas. Taip yra todėl, kad vaizdo kūrimo kontekstas turi būti išsiųstas „Docker“ demonui. Katalogas, vaizduojantis kūrimo kontekstą, pateikiamas kaip paskutinis komandos argumentas docker build. Mūsų atveju šios komandos pabaigoje yra taškas. Dėl to į surinkimo kontekstą įtraukiama tokia struktūra:

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

Tačiau iš visų čia esančių aplankų mums reikia tik aplanko build. Atsisiunčiant ką nors kita yra laiko švaistymas. Galite paspartinti kūrimą, nurodydami „Docker“, kuriuos katalogus ignoruoti. Norėdami tai padaryti, mums reikia failo .dockerignore. Jūs, jei esate susipažinę su failu .gitignore, šio failo struktūra tikriausiai atrodys pažįstama. Jame pateikiami katalogai, kurių vaizdo kūrimo sistema gali nepaisyti. Mūsų atveju šio failo turinys atrodo taip:

node_modules
src
public

byla .dockerignore turi būti tame pačiame aplanke kaip ir failas Dockerfile. Dabar vaizdo surinkimas užtruks kelias sekundes.

Dabar panagrinėkime „Java“ programos vaizdą.

▍Java programos konteinerio vaizdo kūrimas

Žinote ką, ir jau išmokote viską, ko reikia konteinerio vaizdams kurti. Štai kodėl šis skyrius bus labai trumpas.

Atidarykite failą Dockerfile, kuris yra projekto aplanke sa-webapp. Jei perskaitysite šio failo tekstą, tada jame sutiksite tik dvi naujas konstrukcijas, kurios prasideda raktiniais žodžiais ENV и EXPOSE:

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

Raktažodis ENV leidžia deklaruoti aplinkos kintamuosius Docker konteineriuose. Visų pirma, mūsų atveju, tai leidžia nustatyti URL, kad galėtumėte pasiekti programos, kuri atlieka teksto analizę, API.

Raktažodis EXPOSE leidžia nurodyti Docker atidaryti prievadą. Mes ketiname naudoti šį prievadą dirbdami su programa. Čia galite tai pamatyti Dockerfile taikymui SA-Frontend tokios komandos nėra. Tai tik dokumentacijos tikslais, kitaip tariant, ši konstrukcija skirta skaitytojui Dockerfile.

Vaizdo kūrimas ir perkėlimas į saugyklą atrodo lygiai taip pat, kaip ankstesniame pavyzdyje. Jei dar nelabai pasitikite savo sugebėjimais, atitinkamas komandas galite rasti faile README.md aplanke sa-webapp.

▍Python programos konteinerio vaizdo kūrimas

Jei pažvelgsite į failo turinį Dockerfile aplanke sa-logicnieko naujo ten nerasi. Komandos, skirtos sukurti vaizdą ir perkelti jį į saugyklą, jau turėtų būti žinomos, tačiau, kaip ir kitų mūsų programų atveju, jas galite rasti faile README.md aplanke sa-logic.

▍ Konteinerių programų testavimas

Ar galite pasitikėti tuo, ko neišbandėte? as irgi negaliu. Išbandykime savo konteinerius.

1. Pradėkime programos konteinerį sa-logic ir sukonfigūruokite jį klausytis prievado 5050:

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

2. Pradėkime programos konteinerį sa-webapp ir sukonfigūruokite jį klausytis prievado 8080. Be to, turime nustatyti prievadą, kuriame Python programa klausys užklausų iš Java programos, iš naujo priskirdami aplinkos kintamąjį 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

Norėdami sužinoti, kaip sužinoti konteinerio arba Docker VM IP adresą, žr. failą SKAITYK MANE.

Pradėkime programos konteinerį sa-frontend:

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

Dabar viskas yra paruošta naršyti naršyklėje į adresą localhost:80 ir išbandykite programą.

Atkreipkite dėmesį, kad jei pakeisite prievadą sa-webapp, arba jei naudojate Docker VM, turėsite redaguoti failą App.js iš aplanko sa-frontendpakeisdami metodo IP adresą arba prievado numerį analyzeSentence()vietoj pasenusių duomenų pakeičiant dabartinę informaciją. Po to reikia iš naujo surinkti vaizdą ir jį naudoti.

Štai kaip dabar atrodo mūsų taikymo diagrama.

Mikroservisai veikia konteineriuose

Santrauka: kodėl mums reikia „Kubernetes“ klasterio?

Mes ką tik peržiūrėjome failus Dockerfile, kalbėjo apie tai, kaip sukurti vaizdus ir perkelti juos į „Docker“ saugyklą. Be to, sužinojome, kaip paspartinti vaizdų surinkimą naudojant failą .dockerignore. Todėl mūsų mikropaslaugos dabar veikia Docker konteineriuose. Čia jums gali kilti visiškai pagrįstas klausimas, kodėl mums reikia Kubernetes. Atsakymas į šį klausimą bus skirtas antrajai šios medžiagos daliai. Tuo tarpu apsvarstykite šį klausimą:
Tarkime, kad mūsų teksto analizės žiniatinklio programa išpopuliarėjo visame pasaulyje. Kiekvieną minutę jam ateina milijonai prašymų. Tai reiškia, kad mikropaslaugos sa-webapp и sa-logic patirs didžiulį stresą. Kaip pakeisti konteinerius, kuriuose teikiamos mikropaslaugos?

Šaltinis: www.habr.com