🥇Tutorial Kubernetes Pjesa 1: Aplikacionet, Mikroshërbimet dhe Kontejnerët

Me kërkesën tonë, Habr krijoi një qendër Kubernetes dhe kemi kënaqësinë të vendosim botimin e parë në të. Abonohu!

Kubernetes është e lehtë. Pse bankat më paguajnë shumë para për të punuar në këtë fushë, ndërkohë që çdokush mund ta zotërojë këtë teknologji në vetëm pak orë?

Nëse dyshoni se Kubernetes mund të mësohet kaq shpejt, ju sugjeroj të provoni ta bëni vetë. Gjegjësisht, pasi të keni zotëruar këtë material, do të jeni në gjendje të ekzekutoni një aplikacion të bazuar në mikroshërbime në një grup Kubernetes. Unë mund ta garantoj këtë, sepse është në të njëjtën metodologji që përdor këtu që u mësoj klientëve tanë se si të punojnë me Kubernetes. Çfarë e bën këtë udhëzues të ndryshëm nga të tjerët? Në fakt, shumë gjëra. Pra, shumica e këtyre materialeve fillojnë me një shpjegim të gjërave të thjeshta - konceptet e Kubernetes dhe veçoritë e komandës kubectl. Autorët e këtyre artikujve supozojnë se lexuesi i tyre është i njohur me zhvillimin e aplikacioneve, mikroshërbimet dhe kontejnerët Docker. Ne do të shkojmë në anën tjetër. Së pari, le të flasim se si të ekzekutojmë një aplikacion të bazuar në mikroshërbime në një kompjuter. Më pas do të shikojmë ndërtimin e imazheve të kontejnerëve për çdo mikroshërbim. Dhe pas kësaj, ne do të njihemi me Kubernetes dhe do të analizojmë vendosjen e një aplikacioni të bazuar në mikroshërbime në një grup të menaxhuar nga Kubernetes.

Kjo qasje, me një qasje graduale ndaj Kubernetes, do të japë thellësinë e të kuptuarit të asaj që po ndodh që i nevojitet një personi mesatar për të kuptuar se sa thjesht është rregulluar gjithçka në Kubernetes. Kubernetes është sigurisht një teknologji e thjeshtë, me kusht që kushdo që dëshiron ta zotërojë atë, të dijë se ku dhe si përdoret.

Tani, pa vonesë, le të fillojmë punën dhe të flasim për aplikacionin me të cilin do të punojmë.

Aplikacioni eksperimental

Aplikacioni ynë do të kryejë vetëm një funksion. Merr, si hyrje, një fjali, pas së cilës, duke përdorur mjetet e analizës së tekstit, kryen një analizë sentimentale të kësaj fjalie, duke marrë një vlerësim të qëndrimit emocional të autorit të fjalisë ndaj një objekti të caktuar.

Kështu duket dritarja kryesore e këtij aplikacioni.

Aplikacioni ueb i analizës së ndjenjave

Nga pikëpamja teknike, aplikacioni përbëhet nga tre mikroshërbime, secila prej të cilave zgjidh një grup të caktuar detyrash:

SA-Frontend është një server në internet Nginx që shërben skedarët statikë të React.
SA-WebApp është një aplikacion ueb i shkruar në Java që trajton kërkesat nga frontend.
SA-Logic është një aplikacion Python që kryen analizën e ndjenjave të tekstit.

Është e rëndësishme të theksohet se mikroshërbimet nuk ekzistojnë të izoluara. Ata zbatojnë idenë e "ndarjes së detyrave", por ata, në të njëjtën kohë, duhet të ndërveprojnë me njëri-tjetrin.

Të dhënat rrjedhin në aplikacion

Në diagramin e mësipërm, mund të shihni fazat e numëruara të sistemit, duke ilustruar rrjedhat e të dhënave në aplikacion. Le t'i zbërthejmë ato:

Shfletuesi kërkon një skedar nga serveri index.html (e cila nga ana tjetër ngarkon paketën e aplikacionit React).
Përdoruesi ndërvepron me aplikacionin, kjo shkakton një thirrje në një aplikacion në internet bazuar në Spring.
Aplikacioni në ueb e përcjell kërkesën për të analizuar tekstin tek aplikacioni Python.
Aplikacioni Python analizon ndjenjën e tekstit dhe e kthen rezultatin si përgjigje ndaj kërkesës.
Aplikacioni Spring i dërgon një përgjigje aplikacionit React (i cili, nga ana tjetër, i tregon përdoruesit rezultatin e tekstit të analizuar).

Kodi për të gjitha këto aplikacione mund të gjendet këtu. Unë rekomandoj që ta kopjoni këtë depo për veten tuaj tani, pasi ka shumë eksperimente interesante me të përpara nesh.

Ekzekutimi i një aplikacioni të bazuar në mikroshërbime në makinën lokale

Në mënyrë që aplikacioni të funksionojë, duhet të nisim të tre mikroshërbimet. Le të fillojmë me më të bukurat prej tyre - aplikacionin e përparme.

▍ Vendosja e React për zhvillimin lokal

Për të ekzekutuar një aplikacion React, duhet të instaloni kornizën Node.js dhe NPM në kompjuterin tuaj. Pasi të keni instaluar të gjitha këto, shkoni duke përdorur terminalin në dosjen e projektit sa-frontend dhe ekzekutoni komandën e mëposhtme:

npm install

Duke ekzekutuar këtë komandë në dosje node_modules do të ngarkohen varësitë e aplikacionit React, të dhënat e të cilave janë në skedar package.json. Pasi të keni shkarkuar varësitë në të njëjtën dosje, ekzekutoni komandën e mëposhtme:

npm start

Kjo eshte e gjitha. Aplikacioni React tani po funksionon dhe mund të aksesohet duke lundruar në adresën e shfletuesit localhost:3000. Mund të ndryshoni diçka në kodin e tij. Do të shihni menjëherë efektin e këtyre ndryshimeve në shfletues. Kjo është e mundur falë të ashtuquajturit zëvendësim "hot" i moduleve. Falë kësaj, zhvillimi në front-end bëhet një përvojë e thjeshtë dhe e këndshme.

▍Përgatitja e një aplikacioni React për prodhim

Për qëllime të përdorimit të vërtetë të një aplikacioni React, ne duhet ta konvertojmë atë në një grup skedarësh statikë dhe t'u shërbejmë klientëve duke përdorur një server në internet.

Për të ndërtuar aplikacionin React, përsëri duke përdorur terminalin, lundroni te dosja sa-frontend dhe ekzekutoni komandën e mëposhtme:

npm run build

Kjo do të krijojë një direktori në dosjen e projektit build. Ai do të përmbajë të gjithë skedarët statikë që kërkohen për funksionimin e aplikacionit React.

▍Shërbimi i skedarëve statikë me Nginx

Së pari ju duhet të instaloni dhe ekzekutoni serverin e internetit Nginx. Këtu mund ta shkarkoni dhe të gjeni udhëzime për instalimin dhe ekzekutimin e tij. Pastaj ju duhet të kopjoni përmbajtjen e dosjes sa-frontend/build në dosje [your_nginx_installation_dir]/html.

Me këtë qasje, skedari gjenerohet gjatë montimit të aplikacionit React index.html do të jetë në dispozicion në [your_nginx_installation_dir]/html/index.html. Ky është skedari që, si parazgjedhje, serveri Nginx lëshon kur e akseson atë. Serveri është konfiguruar për të dëgjuar në një port 80, por mund ta personalizoni ashtu siç dëshironi duke redaktuar skedarin [your_nginx_installation_dir]/conf/nginx.conf.

Tani hapni shfletuesin tuaj dhe shkoni te localhost:80. Do të shihni faqen e aplikacionit React.

Aplikacioni React i shërbyer nga serveri Nginx

Nëse tani futni diçka në fushë Type your sentence dhe shtypni butonin Send - asgjë nuk do të ndodhë. Por, nëse shikoni në tastierë, mund të shihni mesazhe gabimi atje. Për të kuptuar saktësisht se ku ndodhin këto gabime, le të analizojmë kodin e aplikacionit.

▍Analiza e kodit të aplikacionit front-end

Duke parë kodin e skedarit App.js, mund ta shohim duke klikuar në butonin Send quan një metodë analyzeSentence(). Kodi për këtë metodë është paraqitur më poshtë. Në të njëjtën kohë, kushtojini vëmendje faktit se për secilën rresht në të cilin ka një koment të formularit # Номер, ka një shpjegim të dhënë më poshtë kodit. Në të njëjtën mënyrë, ne do të analizojmë fragmente të tjera të kodit.

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-ja në të cilën është bërë kërkesa POST. Kjo adresë supozohet të jetë një aplikacion që pret kërkesa të tilla.

2.Organi i kërkesës i dërgohet aplikacionit. Këtu është një shembull i trupit të kërkesës:

{
    sentence: "I like yogobella!"
}

3.Kur merret një përgjigje ndaj një kërkese, gjendja e komponentit përditësohet. Kjo bën që komponenti të riprodhohet. Nëse marrim të dhëna (d.m.th., një objekt JSON që përmban të dhënat e futura dhe rezultatin e llogaritur të tekstit), ne do të nxjerrim komponentin Polaritypërderisa plotësohen kushtet. Ja se si e përshkruajmë komponentin:

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

Kodi duket se funksionon mjaft mirë. Çfarë nuk shkon këtu, gjithsesi? Nëse supozoni se në adresën në të cilën aplikacioni po përpiqet të dërgojë një kërkesë POST, nuk ka ende asgjë që mund ta pranojë dhe përpunojë këtë kërkesë, atëherë do të keni absolutisht të drejtë. Gjegjësisht, për të përpunuar kërkesat që vijnë në adresë http://localhost:8080/sentiment, duhet të ekzekutojmë një aplikacion ueb bazuar në Spring.

Ne kemi nevojë për një aplikacion Spring që mund të pranojë një kërkesë POST

▍Konfigurimi i një aplikacioni ueb bazuar në Spring

Për të vendosur një aplikacion Spring, ju nevojiten JDK8 dhe Maven dhe variablat e mjedisit të konfiguruara siç duhet. Pasi të keni instaluar të gjitha këto, mund të vazhdoni të punoni në projektin tonë.

▍ Paketimi i aplikacionit në një skedar jar

Lundroni, duke përdorur terminalin, në dosje sa-webapp dhe shkruani komandën e mëposhtme:

mvn install

Pas ekzekutimit të kësaj komande në dosje sa-webapp drejtoria do të krijohet target. Këtu do të vendoset aplikacioni Java, i paketuar në një skedar jar, i përfaqësuar nga skedari sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ Nisja e një aplikacioni Java

Shkoni te dosja target dhe ekzekutoni aplikacionin me komandën e mëposhtme:

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

Do të ndodhë një gabim gjatë ekzekutimit të kësaj komande. Për të filluar rregullimin e tij, ne mund të analizojmë detajet e përjashtimit në të dhënat e gjurmimit të stivës:

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

Për ne, gjëja më e rëndësishme këtu është përmendja e pamundësisë së sqarimit të kuptimit sa.logic.api.url. Le të analizojmë kodin ku ndodh gabimi.

▍Analiza e kodit të aplikacionit Java

Këtu është pjesa e kodit ku ndodh gabimi.

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

Në SentimentController ka një fushë saLogicApiUrl. Vlera e saj përcaktohet nga prona sa.logic.api.url.
rresht saLogicApiUrl lidhet me vlerën /analyse/sentiment. Së bashku ata formojnë një adresë për të bërë një telefonatë në mikroshërbimin që kryen analizën e tekstit.

▍Vendosja e vlerës së pronës

Në pranverë, burimi i paracaktuar i vlerave të pronës është një skedar application.properties, e cila mund të gjendet në sa-webapp/src/main/resources. Por përdorimi i tij nuk është mënyra e vetme për të vendosur vlerat e pronës. Ju gjithashtu mund ta bëni këtë me komandën e mëposhtme:

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

Vlera e kësaj vetie duhet të tregojë adresën e aplikacionit tonë Python.

Duke e konfiguruar, ne i tregojmë aplikacionit ueb Spring se ku duhet të shkojë për të ekzekutuar kërkesat e analizimit të tekstit.

Për të mos e komplikuar jetën tonë, ne do të vendosim që aplikacioni Python të jetë i disponueshëm në localhost:5000 dhe përpiquni të mos harroni për këtë. Si rezultat, komanda për të nisur aplikacionin Spring do të duket kështu:

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

Sistemit tonë i mungon një aplikacion Python

Tani na mbetet vetëm të ekzekutojmë aplikacionin Python dhe sistemi do të funksionojë siç pritej.

▍Konfigurimi i një aplikacioni Python

Për të ekzekutuar një aplikacion Python, duhet të keni të instaluar Python 3 dhe Pip dhe duhet të keni të vendosur saktë variablat e duhura të mjedisit.

▍Instaloni varësitë

Shkoni te dosja e projektit sa-logic/sa dhe ekzekutoni komandat e mëposhtme:

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

▍Nisja e aplikacionit

Me varësitë e instaluara, ne jemi gati të ekzekutojmë aplikacionin:

python sentiment_analysis.py

Pas ekzekutimit të kësaj komande, do të na thuhet si vijon:

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

Kjo do të thotë që aplikacioni po funksionon dhe pret kërkesat në localhost:5000/

▍Kërkimi i kodit

Le të shohim kodin e aplikacionit Python për të kuptuar se si ai u përgjigjet kërkesave:

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

Inicializimi i objektit Flask.
Përcaktimi i adresës për të bërë kërkesa POST për të.
Marrja e një prone sentence nga organi i kërkesës.
Inicializimi i objektit anonim TextBlob dhe duke marrë vlerën polarity për propozimin e parë të marrë në trupin e kërkesës (në rastin tonë, ky është i vetmi propozim i paraqitur për analizë).
Kthimi i një përgjigjeje, trupi i së cilës përmban tekstin e ofertës dhe treguesin e llogaritur për të polarity.
Nisja e aplikacionit Flask, i cili do të jetë i disponueshëm në 0.0.0.0:5000 (ju gjithashtu mund ta përdorni atë duke përdorur një konstruksion të formularit localhost:5000).

Tani po funksionojnë mikroshërbimet që përbëjnë aplikacionin. Ata janë të vendosur të ndërveprojnë me njëri-tjetrin. Ja se si duket diagrami i aplikimit në këtë fazë të punës.

Të gjitha mikroshërbimet që përbëjnë aplikacionin sillen në një gjendje të shëndetshme

Tani, përpara se të vazhdojmë, hapni aplikacionin React në një shfletues dhe përpiquni të analizoni disa fjali me të. Nëse gjithçka është bërë në mënyrë korrekte - pasi të keni shtypur butonin Send do të shihni rezultatet e analizës poshtë kutisë së tekstit.

Në seksionin tjetër, ne do të flasim për mënyrën e funksionimit të mikroshërbimeve tona në kontejnerët Docker. Kjo është e nevojshme për të përgatitur aplikacionin për të ekzekutuar në grupin Kubernetes.

Kontejnerët Docker

Kubernetes është një sistem për automatizimin e vendosjes, shkallëzimit dhe menaxhimit të aplikacioneve të kontejnerizuara. Quhet edhe “orkestruesi i kontejnerëve”. Nëse Kubernetes punon me kontejnerë, atëherë para se të përdorim këtë sistem, së pari duhet t'i marrim këto kontejnerë. Por së pari, le të flasim se çfarë janë kontejnerët. Ndoshta përgjigja më e mirë për pyetjen se çfarë është ajo mund të gjendet në dokumentacionin te Docker:

Një imazh i kontejnerit është një paketë e lehtë, e pavarur, e ekzekutueshme që përmban një aplikacion, i cili përfshin gjithçka të nevojshme për ta ekzekutuar atë: kodin e aplikacionit, mjedisin e kohës së funksionimit, mjetet dhe bibliotekat e sistemit, cilësimet. Programet me kontejnerë mund të përdoren si në mjediset Linux ashtu edhe në Windows dhe do të funksionojnë gjithmonë njësoj pavarësisht nga infrastruktura.

Kjo do të thotë që kontejnerët mund të ekzekutohen në çdo kompjuter, duke përfshirë serverët e prodhimit, dhe në çdo mjedis, aplikacionet e përfshira në to do të funksionojnë në të njëjtën mënyrë.

Për të eksploruar veçoritë e kontejnerëve dhe për t'i krahasuar ato me mënyra të tjera për të ekzekutuar aplikacionet, le të shohim shembullin e shërbimit të një aplikacioni React duke përdorur një makinë virtuale dhe një kontejner.

▍Shërbimi i skedarëve statikë të një aplikacioni React duke përdorur një makinë virtuale

Duke u përpjekur të organizojmë mirëmbajtjen e skedarëve statikë duke përdorur makina virtuale, do të hasim disavantazhet e mëposhtme:

Përdorimi joefikas i burimeve, pasi çdo makinë virtuale është një sistem operativ i plotë.
Varësia e platformës. Ajo që funksionon në disa kompjuterë lokalë mund të mos funksionojë në një server prodhimi.
Shkallëzimi i ngadalshëm dhe intensiv i burimeve të një zgjidhjeje të makinës virtuale.

Serveri në internet Nginx që shërben skedarë statikë që funksionojnë në një makinë virtuale

Nëse kontejnerët përdoren për të zgjidhur një problem të ngjashëm, atëherë, në krahasim me makinat virtuale, mund të vërehen pikat e mëposhtme të forta:

Përdorimi efikas i burimeve: punoni me sistemin operativ duke përdorur Docker.
Pavarësia e platformës. Një kontejner që një zhvillues mund të ekzekutojë në kompjuterin e tij do të funksionojë kudo.
Zbatim i lehtë përmes përdorimit të shtresave të imazhit.

Serveri në internet Nginx që shërben skedarë statikë që funksionojnë në një kontejner

Ne kemi krahasuar makinat virtuale dhe kontejnerët vetëm në disa pika, por edhe kjo është e mjaftueshme për të kuptuar pikat e forta të kontejnerëve. Këtu Mund të gjeni detaje rreth kontejnerëve Docker.

▍ Ndërtimi i një imazhi të kontejnerit për një aplikacion React

Blloku themelor i ndërtimit të një kontejneri Docker është skedari Dockerfile. Në fillim të këtij skedari, regjistrohet një imazh bazë i kontejnerit, më pas përfshihet një sekuencë udhëzimesh që tregojnë se si të krijoni një enë që do të plotësojë nevojat e një aplikacioni.

Para se të fillojmë punën me skedarin Dockerfile, mbani mend se çfarë bëmë për të përgatitur skedarët e aplikacionit React për ngarkim në serverin Nginx:

Ndërtimi i një pakete aplikacioni React (npm run build).
Nisja e serverit Nginx.
Kopjimi i përmbajtjes së një drejtorie build nga dosja e projektit sa-frontend në dosjen e serverit nginx/html.

Më poshtë mund të shihni paralelet midis krijimit të një kontejneri dhe veprimeve të mësipërme të kryera në kompjuterin lokal.

▍Përgatitja e një skedari Docker për aplikacionin SA-Frontend

Udhëzimet që duhet të përfshihen në Dockerfile për aplikim SA-Frontend, përbëhet nga vetëm dy ekipe. Fakti është se ekipi i zhvillimit Nginx ka përgatitur një bazë imazh për Nginx, të cilin do ta përdorim për të ndërtuar imazhin tonë. Këtu janë dy hapat që duhet të përshkruajmë:

Ju duhet ta bëni imazhin Nginx bazën e imazhit.
Përmbajtja e dosjes sa-frontend/build duhet të kopjohet në dosjen e imazhit nginx/html.

Nëse kalojmë nga ky përshkrim te skedari Dockerfile, atëherë do të duket kështu:

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

Siç mund ta shihni, gjithçka këtu është shumë e thjeshtë, ndërsa përmbajtja e skedarit madje rezulton të jetë mjaft e lexueshme dhe e kuptueshme. Ky skedar i thotë sistemit të marrë imazhin nginx me gjithçka që ka tashmë dhe kopjoni përmbajtjen e drejtorisë build në drejtori nginx/html.

Këtu mund të keni një pyetje në lidhje me mënyrën se si e di se ku të kopjoj saktësisht skedarët nga dosja build, pra nga erdhi rruga /usr/share/nginx/html. Në fakt, as këtu nuk ka asgjë të komplikuar. Fakti është se informacioni përkatës mund të gjendet në përshkrim imazh.

▍Mbledhja e imazhit dhe ngarkimi i tij në depo

Përpara se të punojmë me një imazh të kompletuar, duhet ta dorëzojmë atë në depon e imazhit. Për ta bërë këtë, ne do të përdorim platformën falas të pritjes së imazheve të bazuara në cloud, Docker Hub. Në këtë fazë të punës, duhet të bëni sa më poshtë:

vendos prerës.
Regjistrohuni në faqen e Docker Hub.
Hyni në llogarinë tuaj duke ekzekutuar komandën e mëposhtme në terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Tani ju duhet, duke përdorur terminalin, të shkoni te drejtoria sa-frontend dhe ekzekutoni komandën e mëposhtme atje:

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

Këtu dhe më poshtë në komanda të ngjashme $DOCKER_USER_ID duhet të zëvendësohet me emrin tuaj të përdoruesit në Docker Hub. Për shembull, kjo pjesë e komandës mund të duket si kjo: rinormaloku/sentiment-analysis-frontend.

Në këtë rast, kjo komandë mund të shkurtohet duke hequr prej saj -f Dockerfile, pasi dosja në të cilën e ekzekutojmë këtë komandë tashmë e ka këtë skedar.

Për të dërguar imazhin e përfunduar në depo, ne kemi nevojë për komandën e mëposhtme:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Pas përfundimit të tij, kontrolloni listën tuaj të depove në Docker Hub për të parë nëse imazhi u shty me sukses në ruajtjen e cloud.

▍ Nisja e një kontejneri

Tani çdokush mund të shkarkojë dhe ekzekutojë imazhin e njohur si $DOCKER_USER_ID/sentiment-analysis-frontend. Për ta bërë këtë, duhet të ekzekutoni sekuencën e mëposhtme të komandave:

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

Tani kontejneri po funksionon dhe ne mund të vazhdojmë të punojmë duke krijuar imazhe të tjera që na duhen. Por para se të vazhdojmë, le të kuptojmë dizajnin 80:80, e cila gjendet në komandën për të ekzekutuar imazhin dhe mund të duket konfuze.

Numri i parë 80 është numri i portit të hostit (domethënë kompjuteri lokal).
Numri i dytë 80 është porti i kontejnerit në të cilin duhet të ridrejtohet kërkesa.

Merrni parasysh ilustrimin e mëposhtëm.

Port Forwarding

Sistemi përcjell kërkesat nga porti <hostPort> në port <containerPort>. Kjo është, hyrja në port 80 kompjuteri ridrejtohet në një port 80 enë.

Që nga porti 80 hapur në kompjuterin lokal, mund të përdorni aplikacionin nga ky kompjuter në localhost:80. Nëse sistemi juaj nuk e mbështet Docker, mund ta ekzekutoni aplikacionin në një makinë virtuale Docker, adresa e së cilës do të duket si <docker-machine ip>:80. Për të gjetur adresën IP të makinës virtuale Docker, mund të përdorni komandën docker-machine ip.

Në këtë pikë, pasi kontejneri i aplikacionit të përparmë të jetë nisur me sukses, duhet të jeni në gjendje të hapni faqen e tij në një shfletues.

▍.dockerignore file

Ndërtimi i imazhit të aplikacionit SA-Frontend, mund të vëmë re se ky proces është jashtëzakonisht i ngadaltë. Kjo është për shkak se konteksti i ndërtimit të imazhit duhet të dërgohet te daemon Docker. Drejtoria që përfaqëson kontekstin e ndërtimit jepet si argumenti i fundit i komandës docker build. Në rastin tonë, ka një pikë në fund të kësaj komande. Kjo rezulton në strukturën e mëposhtme që përfshihet në kontekstin e asamblesë:

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

Por nga të gjitha dosjet e pranishme këtu, na duhet vetëm një dosje build. Shkarkimi i çdo gjëje tjetër është humbje kohe. Ju mund ta shpejtoni ndërtimin duke i thënë Docker se cilat drejtori të injorojë. Për ta bërë këtë, na duhet një skedar .dockerignore. Ju, nëse jeni të njohur me dosjen .gitignore, struktura e këtij skedari ndoshta do të duket e njohur. Ai liston drejtoritë që sistemi i krijimit të imazhit mund të injorojë. Në rastin tonë, përmbajtja e këtij skedari duket si kjo:

node_modules
src
public

skedar .dockerignore duhet të jetë në të njëjtën dosje me skedarin Dockerfile. Tani montimi i figurës do të zgjasë disa sekonda.

Le të merremi tani me imazhin për një aplikacion Java.

▍ Ndërtimi i një imazhi të kontejnerit për një aplikacion Java

Ju e dini se çfarë dhe tashmë keni mësuar gjithçka që ju nevojitet për të krijuar imazhe të kontejnerëve. Kjo është arsyeja pse ky seksion do të jetë shumë i shkurtër.

Hapni skedarin Dockerfile, i cili ndodhet në dosjen e projektit sa-webapp. Nëse lexoni tekstin e këtij skedari, atëherë në të do të takoni vetëm dy ndërtime të reja që fillojnë me fjalë kyçe ENV и EXPOSE:

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

Fjalen ENV ju lejon të deklaroni variablat e mjedisit brenda kontejnerëve Docker. Në veçanti, në rastin tonë, ju lejon të vendosni një URL për të hyrë në API të aplikacionit që kryen analizën e tekstit.

Fjalen EXPOSE ju lejon t'i thoni Docker-it të hapë një port. Ne do ta përdorim këtë port gjatë punës me aplikacionin. Këtu mund ta shihni atë në Dockerfile për aplikim SA-Frontend nuk ka një urdhër të tillë. Kjo është vetëm për qëllime dokumentacioni, me fjalë të tjera, ky konstrukt është për lexuesin Dockerfile.

Ndërtimi i imazhit dhe shtyrja e tij në depo duket tamam si shembulli i mëparshëm. Nëse nuk jeni ende shumë të sigurt në aftësitë tuaja, komandat përkatëse mund të gjenden në skedar README.md në dosje sa-webapp.

▍ Ndërtimi i një imazhi të kontejnerit për një aplikacion Python

Nëse i hidhni një sy përmbajtjes së skedarit Dockerfile në dosje sa-logicnuk do të gjeni asgjë të re atje. Komandat për ndërtimin e imazhit dhe shtyrjen e tij në depo duhet të jenë tashmë të njohura për ju, por, si në rastin e aplikacioneve tona të tjera, ato mund të gjenden në skedar README.md në dosje sa-logic.

▍Testimi i aplikacioneve të kontejnerizuara

A mund të besoni diçka që nuk e keni testuar? Unë gjithashtu nuk mundem. Le të testojmë kontejnerët tanë.

Le të fillojmë kontejnerin e aplikimit sa-logic dhe konfiguroni atë për të dëgjuar në një port 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Le të fillojmë kontejnerin e aplikimit sa-webapp dhe konfiguroni atë për të dëgjuar në një port 8080. Përveç kësaj, ne duhet të vendosim portën në të cilën aplikacioni Python do të dëgjojë kërkesat nga aplikacioni Java duke ricaktuar variablin e mjedisit 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
```

Për të mësuar se si të gjeni adresën IP të një kontejneri ose Docker VM, referojuni skedarit README.

Le të fillojmë kontejnerin e aplikimit sa-frontend:

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

Tani gjithçka është gati për të lundruar në shfletues në adresën localhost:80 dhe testoni aplikacionin.

Ju lutemi vini re se nëse ndryshoni portin për sa-webapp, ose nëse po ekzekutoni një Docker VM, do t'ju duhet të redaktoni skedarin App.js nga një dosje sa-frontendduke ndryshuar adresën IP ose numrin e portit në metodë analyzeSentence()duke zëvendësuar informacionin aktual në vend të të dhënave të vjetruara. Pas kësaj, ju duhet të ribashkoni imazhin dhe ta përdorni atë.

Kjo është se si duket diagrami ynë i aplikimit tani.

Mikroshërbimet funksionojnë në kontejnerë

Përmbledhje: pse na duhet një grup Kubernetes?

Sapo kemi shqyrtuar dosjet Dockerfile, foli se si të ndërtoni imazhe dhe t'i shtyni ato në një depo Docker. Për më tepër, mësuam se si të shpejtojmë montimin e imazheve duke përdorur skedarin .dockerignore. Si rezultat, mikroshërbimet tona po funksionojnë tani në kontejnerët Docker. Këtu mund të keni një pyetje plotësisht të justifikuar se pse na duhen Kubernetes. Përgjigja për këtë pyetje do t'i kushtohet pjesës së dytë të këtij materiali. Ndërkohë, merrni parasysh pyetjen e mëposhtme:
Le të supozojmë se aplikacioni ynë në internet për analizën e tekstit është bërë i njohur në mbarë botën. Miliona kërkesa i vijnë çdo minutë. Kjo do të thotë se mikroshërbimet sa-webapp и sa-logic do të jetë nën stres të madh. Si të shkallëzohen kontejnerët që përdorin mikroshërbime?

Burimi: www.habr.com

Tutorial Kubernetes Pjesa 1: Aplikacionet, Mikroshërbimet dhe Kontejnerët