🥇Rêbera Kubernetes, Beş 1: Serlêdan, Mîkroxizmet, û Konteyniran

Li ser daxwaza me, Habrê navendek çêkir Kubernetes û em kêfxweş in ku weşana yekem tê de cih digirin. Subscribe!

Kubernetes hêsan e. Çima bank gelek drav didin min da ku di vî warî de bixebitim, dema ku her kes dikare tenê di çend demjimêran de vê teknolojiyê master bike?

Heke hûn guman dikin ku Kubernetes dikare ewqas zû fêr bibe, ez pêşniyar dikim ku hûn bi xwe biceribînin. Ango, piştî ku hûn vê materyalê master bikin, hûn ê bikaribin serîlêdanek li ser bingeha mîkroxizmetên di komek Kubernetes de bimeşînin. Ez dikarim vê garantî bikim, ji ber ku ew bi rastî heman metodolojiya ku li vir tê bikar anîn e ku ez xerîdarên me hîn dikim ku bi Kubernetes re bixebitin. Çi ev rêber ji yên din cuda dike? Bi rastî jî gelek tişt hene. Ji ber vê yekê, piraniya van materyalan bi ravekirina tiştên hêsan dest pê dikin - têgehên Kubernetes û taybetmendiyên fermana kubectl. Nivîskarên van materyalan texmîn dikin ku xwendevanên wan bi pêşkeftina serîlêdanê, mîkroxizmet û konteynerên Docker re nas dikin. Em ê bi awayekî din biçin. Pêşîn, em ê biaxivin ka meriv çawa serîlêdanek li ser bingeha mîkroxizmetên li ser komputerê dimeşîne. Dûv re em ê li wêneyên konteynerê ji bo her mîkroservisê binihêrin. Û piştî wê, em ê bi Kubernetes re nas bikin û li bicîhkirina serîlêdanek li ser bingeha mîkroxizmetên di komek ku ji hêla Kubernetes ve hatî rêve kirin de binihêrin.

Ev nêzîkatî, bi nêzîkbûnek gav bi gav ji Kubernetes re, dê kûrahiya têgihiştina tiştê ku diqewime ku ji bo kesê navînî hewce ye bide fêm kirin ka meriv çawa her tişt di Kubernetes de bi hêsanî dixebite. Kubernetes bê guman teknolojiyek hêsan e, bi şertê ku yên ku dixwazin wê fêr bibin zanibin ew li ku û çawa tê bikar anîn.

Naha, bêyî hûrgulî, werin em dest pê bikin û li ser serîlêdana ku em ê pê re bixebitin bipeyivin.

Serîlêdana ezmûnî

Serlêdana me dê tenê yek fonksiyonê pêk bîne. Ew yek hevokê wekî têketinê digire, pişt re, bi karanîna amûrên analîzkirina nivîsê, analîza hestiyariyê ya vê hevokê dike, nirxandinek helwesta hestyarî ya nivîskarê hevokê li hember tiştek diyarkirî digire.

Pencera sereke ya vê serîlêdanê bi vî rengî xuya dike.

Serlêdana Webê ji bo analîzkirina hestê ya nivîsan

Ji hêla teknîkî ve, serîlêdan ji sê mîkroxizmetan pêk tê, ku her yek ji wan komek pirsgirêkek taybetî çareser dike:

SA-Frontend serverek malperê Nginx e ku pelên React yên statîk re xizmet dike.
SA-WebApp serîlêdanek webê ye ku bi Java-yê hatî nivîsandin e ku daxwazên ji pêşiyê pêvajoyê dike.
SA-Logic serîlêdanek Python e ku analîza hestê li ser nivîsê dike.

Girîng e ku meriv bala xwe bide servîsên mîkro di veqetandinê de tune. Ew ramana "veqetandina berpirsiyariyan" bicîh dikin, lê di heman demê de ew hewce ne ku bi hevûdu re têkilî daynin.

Daneyên di serîlêdanê de diherikin

Di diagrama jor de, hûn dikarin qonaxên hejmarkirî yên pergalê bibînin, ku herikîna daneyê di serîlêdanê de destnîşan dikin. Ka em li wan binêrin:

Gerok pelek ji serverê daxwaz dike index.html (ku, di encamê de, pakêta serîlêdana React dakêşîne).
Bikarhêner bi serîlêdanê re têkildar dibe, ev dibe sedema bangek ji serîlêdana web-a-based Spring.
Serlêdana webê daxwaza pêkanîna analîza nivîsê ji serîlêdana Python re dişîne.
Serlêdana Python analîza hestê ya nivîsê dike û encamê wekî bersivek daxwazê vedigerîne.
Serlêdana Spring bersivek ji serîlêdana React re dişîne (ku, di encamê de, encama analîza nivîsê ji bikarhênerê re nîşan dide).

Koda ji bo van hemî serlêdanan dikare were dîtin vir. Ez pêşniyar dikim ku hûn vê depoyê ji xwe re rast bikin kopî, ji ber ku li pêşiya me gelek ceribandinên balkêş hene.

Li ser makîneya xweya herêmî serîlêdanek-based microservices dimeşîne

Ji bo ku serîlêdan bixebite, divê em her sê mîkroxizmetan bidin destpêkirin. Ka em bi ya herî xweş ji wan dest pê bikin - serîlêdana pêşîn-end.

▍Ji bo pêşveçûna herêmî React saz bikin

Ji bo ku hûn serîlêdanek React bimeşînin, hûn hewce ne ku platforma Node.js û NPM li ser komputera xwe saz bikin. Gava ku we van hemî saz kir, termînalê bikar bînin ku li peldanka projeya xwe bigerin sa-frontend û emrê jêrîn bimeşînin:

npm install

Bi xebitandina vê fermanê di peldankê de node_modules girêdayîbûna serîlêdana React-ê dê werin barkirin, tomarên ku di pelê de ne package.json. Gava ku girêdayî di heman peldankê de têne dakêşandin, emrê jêrîn bimeşînin:

npm start

Navê pêger. Naha serîlêdana React dimeşîne, hûn dikarin bi çûna navnîşana jêrîn a di geroka xwe de bigihîjin wê: localhost:3000. Hûn dikarin di koda wê de tiştek biguherînin. Hûn ê tavilê bandora van guhertinan di gerokê de bibînin. Ev bi saya guheztina modulên bi navê "germ" gengaz e. Ev pêşkeftina pêş-endê ezmûnek hêsan û kêfxweş dike.

▍Amadekirina serîlêdana React ji bo hilberînê

Ji bo mebesta ku em bi rastî serîlêdanek React bikar bînin, pêdivî ye ku em wê veguhezînin komek pelên statîk û wan ji xerîdar re bi karanîna serverek webê re xizmet bikin.

Ji bo avakirina serîlêdana React, dîsa bi karanîna termînalê, li peldankê bigerin sa-frontend û emrê jêrîn bimeşînin:

npm run build

Ev ê di peldanka projeyê de pelrêçek çêbikin build. Ew ê hemî pelên statîk ên ku ji bo xebitandina serîlêdana React hewce ne dihewîne.

▍Pelên statîk bi karanîna Nginx re xizmet dikin

Pêşî hûn hewce ne ku servera malperê Nginx saz bikin û bimeşînin. Ev e hûn dikarin wê dakêşin û rêwerzên li ser çawa sazkirin û xebitandinê bibînin. Dûv re hûn hewce ne ku naveroka peldankê kopî bikin sa-frontend/build ji bo peldankê [your_nginx_installation_dir]/html.

Bi vê nêzîkbûnê, pelê ku di pêvajoya avakirina serîlêdana React de hatî çêkirin index.html dê peyda bibe li [your_nginx_installation_dir]/html/index.html. Ev pelê ye ku, ji hêla xwerû, servera Nginx dema ku digihîje wê çêdike. Pêşkêşkar ji bo guhdarîkirina li portê hatî mîheng kirin 80, lê ew dikare bi awayê ku hûn hewce ne bi guherandina pelê were xweş kirin [your_nginx_installation_dir]/conf/nginx.conf.

Niha geroka xwe vekin û biçin localhost:80. Hûn ê rûpela serîlêdana React bibînin.

Serlêdana React ku ji hêla servera Nginx ve hatî xizmet kirin

Heke hûn niha tiştek têkevin zeviyê Type your sentence û pêl bişkoka Send - Tiştek nabe. Lê, heke hûn li konsolê binêrin, hûn dikarin li wir peyamên xeletiyê bibînin. Ji bo ku em fêm bikin ka ev xeletî li ku derê çêdibin, em koda serîlêdanê analîz bikin.

▍Analîzkirina koda serîlêdana pêşîn

Awirek li koda pelê digirin App.js, em dikarin bibînin ku pêlkirina bişkojê Send rêbazek bang dike analyzeSentence(). Koda vê rêbazê li jêr tê dayîn. Ji kerema xwe not bikin ku ji bo her rêzek ku şîroveyek formê heye # Номер, li jêr kodê ravekirinek heye. Em ê parçeyên din ên kodê bi heman rengî analîz bikin.

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-ya ku daxwaza POST tê kirin. Tê texmîn kirin ku li vê navnîşanê serîlêdanek heye ku daxwazên weha hêvî dike.

2.Saziya daxwaznameyê ji serîlêdanê re şand. Li vir mînakek laşê daxwaznameyê ye:

{
    sentence: "I like yogobella!"
}

3.Dema ku bersivek daxwazek tê wergirtin, rewşa pêkhateyê tê nûve kirin. Ev dibe sedem ku hêman ji nû ve were pêşkêş kirin. Ger em daneyan wergirin (ango tiştek JSON ku daneyên têketinê û xala nivîsê ya hesabkirî dihewîne), em ê beşê derxînin. Polarity, ji ber ku şert û mercên guncaw dê pêk bên. Bi vî rengî em pêkhateyê vedibêjin:

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

Wusa xuya dike ku kod pir baş dixebite. Di vê yekê de çi xelet e? Ger hûn texmîn bikin ku li navnîşana ku serîlêdan hewl dide daxwazek POST bişîne, hîn tiştek tune ku bikaribe vê daxwazê qebûl bike û pêvajoyê bike, wê hingê hûn ê bi tevahî rast bin. Ango, ji bo pêvajoyên daxwazên ku li http://localhost:8080/sentiment, pêdivî ye ku em serîlêdanek malperê li ser Biharê bimeşînin.

Pêdiviya me bi serîlêdanek Biharê heye ku dikare daxwazek POST qebûl bike

▍Damezrandina serîlêdana webê ya biharê

Ji bo ku hûn serîlêdanek Biharê bicîh bikin, hûn ê hewceyê JDK8 û Maven û guhêrbarên jîngehê yên bi rêkûpêk werin mîheng kirin. Dema ku we ev hemî saz kirin, hûn dikarin li ser projeya me xebata xwe bidomînin.

▍Paketkirina serîlêdanê di pelek jar de

Li peldankê, bi karanîna termînalekê, bigerin sa-webapp û emrê jêrîn binivîse:

mvn install

Piştî ku vê fermanê di peldankê de dimeşîne sa-webapp pelrêçek dê were çêkirin target. Li vir e ku serîlêdana Java-ê dê di pelek jar de were pak kirin, ku ji hêla pelê ve tê temsîl kirin sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ Serlêdanek Java dimeşîne

Biçe peldankê target û bi fermana jêrîn serîlêdanê bimeşînin:

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

Di dema pêkanîna vê fermanê de dê xeletiyek derkeve. Ji bo ku em dest bi rastkirina wê bikin, em dikarin hûrguliyên îstîsnayê yên di daneyên şopa stackê de analîz bikin:

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

Li vir ji bo me ya herî girîng behsa nepêkanîna zelalkirina wateyê ye sa.logic.api.url. Ka em koda ku tê de xeletî çêdibe analîz bikin.

▍Analîzkirina koda serîlêdana Java

Li vir perçeya kodê ye ku xeletî lê çêdibe.

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

Li SentimentController zeviyek heye saLogicApiUrl. Nirxa wê ji hêla milkê ve tête diyar kirin sa.logic.api.url.
Xet saLogicApiUrl bi nirxê re têkildar dibe /analyse/sentiment. Bi hev re ew navnîşana ji bo bangewaziya mîkroxizmeta ku analîza nivîsê pêk tîne ava dikin.

▍Nirxek taybetmendiyê saz bike

Di Biharê de, çavkaniya standard a nirxên milkê pelek e application.properties, ku dikare li ser were dîtin sa-webapp/src/main/resources. Lê karanîna wê ne tenê rêyek e ku meriv nirxên milkê destnîşan bike. Ev jî bi karanîna fermana jêrîn dikare were kirin:

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

Nirxa vê milkê divê navnîşana serîlêdana meya Python nîşan bide.

Bi veavakirina wê, em ji sepana weba Spring re vedibêjin ku ew pêdivî ye ku biçe ku derê da ku daxwazên analîzkirina nivîsê pêk bîne.

Ji bo ku jiyana me tevlihev nebe, em ê biryar bidin ku serîlêdana Python dê li wir peyda bibe localhost:5000 û em hewl bidin ku wê ji bîr nekin. Wekî encamek, fermana destpêkirina serîlêdana Spring dê bi vî rengî xuya bike:

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

Pergala me serîlêdanek Python winda dike

Naha ya ku divê em bikin ev e ku serlêdana Python bimeşînin û pergal dê wekî ku tê hêvî kirin bixebite.

▍Sazkirina serîlêdana Python

Ji bo ku hûn serîlêdanek Python bimeşînin, divê hûn Python 3 û Pip sazkirî bin, û guhêrbarên hawîrdorê yên guncan divê rast werin danîn.

▍Sazkirina pêwendiyan

Biçe peldanka projeya xwe sa-logic/sa û emrên jêrîn bimeşînin:

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

▍ Serlêdanê bidin destpêkirin

Piştî sazkirina girêdanan, em amade ne ku serîlêdanê bimeşînin:

python sentiment_analysis.py

Piştî xebitandina vê fermanê dê ji me re jêrîn were gotin:

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

Ev tê vê wateyê ku serîlêdan dimeşe û li benda daxwazan e localhost:5000/

▍ Lêkolîna Kodê

Ka em li koda serîlêdana Python binêrin da ku fêm bikin ka ew çawa bersivê dide daxwazan:

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

Destpêkirina objeyekê Flask.
Diyarkirina navnîşanek ji bo pêkanîna daxwazên POST-ê jê re.
Vegerandina Taybetmendiyek sentence ji laşê daxwazê.
Destpêkirina Tiştek Anonîm TextBlob û wergirtina nirxê polarity ji bo hevoka yekem a ku di laşê daxwazê de hatî wergirtin (di rewşa me de, ev yek tenê hevok e ku ji bo analîzê hatî şandin).
Vegerandina bersivek ku di laşê wê de metna hevokê û nîşana hesabkirî ya wê heye polarity.
Serlêdanek Flask dest pê bikin, ku dê li ser peyda bibe 0.0.0.0:5000 (Hûn dikarin bi karanîna avakirina formê jî bigihîjin wê localhost:5000).

Mikroxizmetên ku serîlêdanê pêk tînin niha dixebitin. Ew ji bo ku bi hevûdu re têkilî bikin têne çêkirin. Di vê qonaxa xebatê de diyagrama serîlêdanê bi vî rengî xuya dike.

Hemî mîkroxizmetên ku serîlêdanê pêk tînin di rêza xebatê de têne danîn

Naha, berî ku hûn bidomînin, serîlêdana React-a xwe di gerokek de vekin û hewl bidin ku hin hevok bi wê re parve bikin. Ger her tişt rast hatî çêkirin - piştî pêlkirina bişkojê Send hûn ê encamên analîzê li binê qada nivîsê bibînin.

Di beşa paşîn de, em ê biaxivin ka meriv çawa mîkroxizmetên xwe di konteynerên Docker de dimeşîne. Ji bo amadekirina serîlêdanê ku li ser koma Kubernetes were xebitandin ev pêdivî ye.

Konteynirên Docker

Kubernetes pergalek ji bo otomatîzekirin, pîvandin û birêvebirina sepanên konteynirkirî ye. Jê re "orkestratorê konteyner" jî tê gotin. Ger Kubernetes bi konteyneran re bixebite, wê hingê berî ku vê pergalê bikar bînin divê em pêşî van konteyneran bistînin. Lê pêşî, bila em bipeyivin ka konteynir çi ne. Dibe ku bersiva herî baş a pirsa ku ew çi ye di nav de were dîtin belgekirin ji Docker re:

Wêneyek konteynerê pakêtek sivik, xwegirtî, pêkan e ku serîlêdanek vedihewîne, ku tê de her tiştê ku ji bo xebitandina wê hewce ye dihewîne: koda serîlêdanê, hawîrdora darvekirinê, amûrên pergalê û pirtûkxane, mîhengan. Bernameyên konteynerkirî dikarin di hawîrdorên Linux û Windows-ê de werin bikar anîn, û ew ê her gav heman binesaziyê bixebitin.

Ev tê vê wateyê ku konteynir dikarin li ser her komputerê, tevî serverên hilberînê, werin xebitandin, û sepanên ku di wan de hene dê di her hawîrdorê de heman kar bikin.

Ji bo vekolîna taybetmendiyên konteyneran û berhevkirina wan bi awayên din ên xebitandina sepanan re, werin em li mînakek xizmetkirina serîlêdana React-ê bi karanîna makîneyek virtual û konteynir binêrin.

▍Xizmetkirina pelên statîk ên serîlêdana React bi karanîna makîneyek virtual

Hewl didin ku karûbarê pelên statîk bi karanîna makîneyên virtual organîze bikin, em ê bi kêmasiyên jêrîn re rû bi rû bimînin:

Bikaranîna bêkêmasî ya çavkaniyan, ji ber ku her makîneya virtual pergalek xebitandinê ya bêkêmasî ye.
Girêdana platformê. Tiştê ku li ser komputerek herêmî dixebite dibe ku li ser serverek hilberînê nexebite.
Pîvana hêdî û çavkanî-dijwar a çareseriyek-based makîneya virtual.

Pêşkêşkara malperê Nginx pelên statîk ên ku li ser makîneyek virtual dixebitin pêşkêş dike

Ger konteyneran ji bo çareserkirina pirsgirêkek wekhev têne bikar anîn, wê hingê, li gorî makîneyên virtual, hêzên jêrîn dikarin werin destnîşan kirin:

Bikaranîna jêhatî ya çavkaniyan: bi pergala xebitandinê re bi karanîna Docker re dixebitin.
Platforma serbixwe. Konteynirek ku pêşdebirek dikare li ser komputera xwe bixebite dê li her deverê bixebite.
Rakirina sivik bi karanîna qatên wêneyê.

Pêşkêşkara webê Nginx pelên statîk ên ku di konteynir de dixebitin pêşkêş dike

Me tenê makîneyên virtual û konteyneran li ser çend xalan dan ber hev, lê tewra ev jî bes e ku meriv bi hêza konteyneran hîs bike. Ev e Hûn dikarin hûrguliyên li ser konteynerên Docker bibînin.

▍Avakirina wêneyek konteynerê ji bo serîlêdana React

Bloka avakirina bingehîn a konteynirek Docker pel e Dockerfile. Di destpêka vê pelê de, tomarek ji wêneya bingehîn a konteynerê tê çêkirin, dûv re rêzek rêwerzan heye ku meriv çawa konteynerek biafirîne ku dê hewcedariyên serîlêdanek diyarkirî bicîh bîne.

Berî ku em dest bi xebata pelê bikin Dockerfile, em bînin bîra xwe ku me çi kir da ku pelên serîlêdana React ji bo barkirina servera Nginx amade bikin:

Avakirina pakêtek serîlêdana React (npm run build).
Pêşkêşkara Nginx dest pê dike.
Kopîkirina naveroka pelrêçê build ji peldanka projeyê sa-frontend peldanka serverê nginx/html.

Li jêr hûn dikarin paralelên di navbera afirandina konteynir û gavên jorîn ên ku li ser komputera weya herêmî têne kirin de bibînin.

▍Amadekirina Dockerfile ji bo serîlêdana SA-Frontend

Talîmatên ku dê di nav de bin Dockerfile ji bo serîlêdanê SA-Frontend, tenê ji du tîman pêk tê. Rastî ev e ku tîmê pêşkeftina Nginx bingehek amade kiriye wêneyek ji bo Nginx, ku em ê bikar bînin ku wêneyê xwe çêbikin. Ev du gavên ku divê em rave bikin ev in:

Bingeha wêneyê divê wêneya Nginx be.
Naveroka Peldanka sa-frontend/build pêdivî ye ku li peldanka wêneyê were kopî kirin nginx/html.

Ger hûn ji vê danasînê derbasî pelê bibin Dockerfile, wê hingê dê wiha xuya bike:

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

Wekî ku hûn dikarin bibînin, her tişt li vir pir hêsan e, û naveroka pelê jî pir tê xwendin û têgihîştin. Ev pel ji pergalê re dibêje ku wêneyê bigire nginx bi her tiştê ku berê tê de ye, û naveroka pelrêçê kopî bikin build bi pelrêça nginx/html.

Li vir dibe ku pirsek we hebe ku ez çawa dizanim ku hûn tam hewce ne ku hûn pelan ji peldankê kopî bikin build, yanî rê ji ku hat /usr/share/nginx/html. Bi rastî, li vir jî tiştek tevlihev tune. Rastî ev e ku agahdariya têkildar dikare tê de were dîtin terîf wêne.

▍ Avakirina wêneyê û barkirina wê li depoyê

Berî ku em karibin bi wêneya qediyayî re bixebitin, pêdivî ye ku em wê berbi depoya wêneyê vekêşin. Ji bo vê yekê, em ê platforma mêvandariya wêneya cloudê ya belaş Docker Hub bikar bînin. Di vê qonaxa xebatê de hûn hewce ne ku jêrîn bikin:

Sazkirin Docker.
Li ser malpera Docker Hub qeyd bikin.
Bi xebitandina fermana jêrîn di termînalê de têkevin hesabê xwe:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Naha hûn hewce ne ku termînalê bikar bînin da ku biçin pelrêça sa-frontend û emrê jêrîn li wir bicîh bikin:

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

Li vir û bêtir di emrên wekhev de $DOCKER_USER_ID divê bi navê bikarhênerê xweya Docker Hub were guheztin. Mînakî, ev beşa fermanê dibe ku bi vî rengî xuya bike: rinormaloku/sentiment-analysis-frontend.

Di vê rewşê de, ev ferman dikare bi jêbirina wê were kurt kirin -f Dockerfile, ji ber ku ev pel jixwe di peldanka ku em tê de vê fermanê pêk tînin de heye.

Ji bo ku em wêneya qediyayî ji depoyê re bişînin, em hewceyê fermana jêrîn in:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Piştî qedandina wê, navnîşa depoyên xwe yên li ser Docker Hub kontrol bikin da ku hûn fêm bikin ka barkirina wêneyê li hilanîna cloudê serketî bû.

▍Rewning a konteynir

Naha her kes dikare wêneyê ku wekî tê zanîn dakêşîne û bixebite $DOCKER_USER_ID/sentiment-analysis-frontend. Ji bo ku hûn vê bikin, hûn hewce ne ku rêzika fermanên jêrîn bimeşînin:

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

Naha konteynir dimeşe, em dikarin bi afirandina wêneyên din ên ku ji me re hewce ne, xebatê bidomînin. Lê berî ku em bidomînin, werin em sêwiranê fam bikin 80:80, ku di fermana destpêkirina wêneyê de xuya dike û dibe ku tevlihev xuya bike.

Hejmara yekem 80 - ev jimareya porta mêvandar e (ango, komputera herêmî).
Hejmara duyemîn 80 porta konteynerê ye ku divê daxwaz jê re were şandin.

Nimûneya jêrîn bifikirin.

Port Forwarding

Pergal daxwazên ji portê beralî dike <hostPort> ber bi benderê <containerPort>. Ango gihîştina benderê 80 komputer ber bi portê ve tê veguhestin 80 têrr.

Ji ber port 80 li ser komputera herêmî hate vekirin, wê hingê hûn dikarin ji vê komputerê bigihîjin serîlêdanê localhost:80. Ger pergala we Docker piştgirî neke, serîlêdan dikare li ser makîneyek virtual ya Docker-ê were xebitandin, navnîşana ku dê mîna xuya bike <docker-machine ip>:80. Ji bo ku hûn navnîşana IP-ya makîneya virtual Docker bibînin, hûn dikarin fermanê bikar bînin docker-machine ip.

Di vê nuqteyê de, piştî bi serfirazî destpêkirina konteynera serîlêdana pêş-endê, divê hûn karibin rûpela wê di gerokê de vekin.

▍Pelê .dockerignore

Komkirina wêneyek serîlêdanê SA-Frontend, em dikarin bala xwe bidin ku ev pêvajo pir hêdî diqewime. Ev diqewime ji ber ku çarçoweya avakirina wêneyê divê ji Daemonê Docker re were şandin. Pelrêça ku çarçoveya avakirinê temsîl dike wekî argumana paşîn a fermanê tê destnîşan kirin docker build. Di rewşa me de, di dawiya vê fermanê de xalek heye. Ev dibe sedem ku strukturên jêrîn di çarçoveyek avakirinê de were nav kirin:

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

Lê ji hemî peldankên ku li vir hene, em tenê peldankê hewce dikin build. Barkirina tiştekî din windakirina demê ye. Hûn dikarin avahîsaziyê bilezînin ji hêla Docker-ê vebêjin ku kîjan pelrêçan paşguh bike. Ji bo ku em vê yekê bikin hewcedariya me bi pelê heye .dockerignore. Tu, eger hûn bi pelê nas in .gitignore, strukturê vê pelê belkî dê nas xuya bike. Ew navnîşan navnîşan dike ku pergala avakirina wêneyê dikare paşguh bike. Di rewşa me de, naveroka vê pelê wiha xuya dike:

node_modules
src
public

file .dockerignore divê di peldanka heman pelê de be Dockerfile. Naha avakirina wêneyê dê çend saniyan bigire.

Ka em niha li ser wêneyê ji bo serîlêdana Java-yê bixebitin.

▍Avakirina wêneyek konteynerê ji bo serîlêdana Java

Hûn dizanin çi, we berê her tiştê ku hûn hewce ne ku ji bo afirandina wêneyên konteynerê zanibin fêr bûne. Ji ber vê yekê ev beş dê pir kurt be.

Pelê vekin Dockerfileku di peldanka projeyê de ye sa-webapp. Heke hûn nivîsa vê pelê bixwînin, hûn ê tê de tenê du avahiyên nû bibînin, ku bi peyvên sereke dest pê dikin ENV и EXPOSE:

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

Keyword ENV Destûrê dide we ku hûn guhêrbarên jîngehê di hundurê konteynerên Docker de ragihînin. Bi taybetî, di doza me de, ew dihêle hûn URLek diyar bikin da ku bigihîjin API-ya serîlêdana ku analîza nivîsê dike.

Keyword EXPOSE dihêle hûn ji Docker re bibêjin ku portek veke. Em ê dema ku serîlêdanê dimeşînin vê portê bikar bînin. Li vir hûn dikarin wê yekê bibînin Dockerfile ji bo serîlêdanê SA-Frontend fermanek wisa tune. Ev tenê ji bo mebestên belgekirinê ye, bi gotineke din, ev avahî ji bo yê ku dê bixwîne tê armanc kirin Dockerfile.

Avakirina wêneyê û kişandina wê ber bi depoyê ve tam wekî mînaka berê xuya dike. Heke hûn hîn jî di qabiliyetên xwe de pir ne ewle ne, emrên têkildar dikarin di pelê de werin dîtin README.md di peldankê de sa-webapp.

▍Avakirina wêneyek konteynerê ji bo serîlêdana Python

Ger hûn li naveroka pelê binêrin Dockerfile di peldankê de sa-logic, wê hingê hûn ê li wir ji xwe re tiştek nû nebînin. Fermanên ji bo avakirina wêneyê û şandina wê ji depoyê re jî divê jixwe ji we re nas bin, lê, wekî serîlêdanên me yên din, ew dikarin di pelê de werin dîtin. README.md di peldankê de sa-logic.

▍Testkirina sepanên konteynerkirî

Ma hûn dikarin ji tiştê ku we ceribandî bawer bikin? Ez jî nikarim. Werin em konteynerên xwe biceribînin.

Ka em konteynera serîlêdanê bidin destpêkirin sa-logic û wê mîheng bikin ku li portê guhdarî bike 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Ka em konteynera serîlêdanê bidin destpêkirin sa-webapp û wê mîheng bikin ku li portê guhdarî bike 8080. Wekî din, pêdivî ye ku em porta ku li ser wê sepana Python dê li daxwazên serîlêdana Java-yê guhdarî bike bi veguheztina guhêrbara jîngehê ve mîheng bikin. 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
```

Ji bo fêr bibin ka meriv çawa navnîşana IP-ya konteynerek Docker an makîneyek virtual fêr dibe, serî li pelê bidin BIXWÎNE.

Ka em konteynera serîlêdanê bidin destpêkirin sa-frontend:

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

Niha her tişt amade ye ku biçe navnîşana gerokê localhost:80 û serîlêdanê biceribînin.

Ji kerema xwe not bikin ku heke we portê ji bo guhert sa-webapp, an heke hûn makîneyek virtual ya Docker dimeşînin, hûn ê hewce bikin ku pelê biguherînin App.js ji peldankê sa-frontendbi guherandina navnîşana IP-ê an jimareya portê ya di rêbazê de analyzeSentence(), li şûna daneyên kevnar agahdariya heyî biguhezîne. Piştî vê yekê, hûn hewce ne ku wêneyê ji nû ve bicivînin û wê bikar bînin.

Tiştê ku diyagrama serîlêdana me nuha xuya dike ev e.

Microservices di konteyneran de dixebitin

Kurte: çima em hewceyê komek Kubernetes in?

Me tenê dosya lêkolîn kir Dockerfile, behsa çawaniya avakirina wêneyan û avêtina wan li depoyek Docker kir. Wekî din, em fêr bûn ka meriv çawa bi karanîna pelê berhevkirina wêneyê bileztir dike .dockerignore. Wekî encamek, mîkroxizmetên me naha di konteynerên Docker de dixebitin. Li vir dibe ku we pirsek bi tevahî rastdar hebe ka çima em hewceyê Kubernetes in. Beşa duyemîn a vê materyalê dê ji bo bersivdana vê pirsê were veqetandin. Di vê navberê de, li ser pirsa jêrîn bifikirin:
Ka em texmîn bikin ku serîlêdana meya webê ya ji bo analîzkirina nivîsê li çaraliyê cîhanê populer bûye. Her deqeyekê bi milyonan daxwaz jê re tên. Ev tê wê wateyê ku microservices sa-webapp и sa-logic dê di bin barek mezin de be. Meriv çawa konteynerên ku mîkroxizmetên xebitandinê didin pîvandin?

Source: www.habr.com

Kubernetes Tutorial Part 1: Serlêdan, Mîkroxizmet, û Konteyniran