Mafunzo ya Kubernetes Sehemu ya 1: Maombi, Huduma Ndogo, na Vyombo

Kwa ombi letu, Habr aliunda kitovu Mabernet na tunafurahi kuweka kichapo cha kwanza humo. Jisajili!

Kubernetes ni rahisi. Kwa nini benki hunilipa pesa nyingi kufanya kazi katika eneo hili, wakati mtu yeyote anaweza kujua teknolojia hii kwa saa chache tu?

Ikiwa una shaka kuwa Kubernetes inaweza kujifunza haraka sana, ninapendekeza ujaribu mwenyewe. Yaani, ukiwa umejua nyenzo hii, utaweza kuendesha programu kulingana na huduma ndogo kwenye nguzo ya Kubernetes. Ninaweza kuhakikisha hili, kwa kuwa ni mbinu ile ile inayotumika hapa kwamba ninawafundisha wateja wetu kufanya kazi na Kubernetes. Ni nini kinachofanya mwongozo huu kuwa tofauti na wengine? Kwa kweli, kuna mambo mengi. Kwa hivyo, nyenzo nyingi hizi huanza na maelezo ya vitu rahisi - dhana za Kubernetes na sifa za amri ya kubectl. Waandishi wa nyenzo hizi wanadhani kuwa wasomaji wao wanajua maendeleo ya programu, huduma ndogo, na vyombo vya Docker. Tutaenda kwa njia nyingine. Kwanza, tutazungumzia jinsi ya kuendesha programu kulingana na microservices kwenye kompyuta. Kisha tutaangalia kujenga picha za chombo kwa kila huduma ndogo. Na baada ya hapo, tutafahamiana na Kubernetes na tutaangalia kupeleka programu kulingana na huduma ndogo katika kundi linalosimamiwa na Kubernetes.

Njia hii, na mbinu ya taratibu kwa Kubernetes, itatoa uelewa wa kina wa kile kinachotokea ambacho ni muhimu kwa mtu wa kawaida ili kuelewa jinsi kila kitu kinavyofanya kazi katika Kubernetes. Kubernetes hakika ni teknolojia rahisi, mradi tu wale wanaotaka kujifunza wanajua inatumika wapi na jinsi gani.

Sasa, bila ado zaidi, wacha tuanze na tuzungumze juu ya programu ambayo tutafanya kazi nayo.

Programu ya majaribio

Maombi yetu yatafanya kazi moja tu. Inachukua sentensi moja kama pembejeo, baada ya hapo, kwa kutumia zana za uchambuzi wa maandishi, hufanya uchambuzi wa hisia za sentensi hii, kupata tathmini ya mtazamo wa kihemko wa mwandishi wa sentensi kwa kitu fulani.

Hivi ndivyo dirisha kuu la programu hii linavyoonekana.

Programu ya wavuti kwa uchambuzi wa hisia za maandishi

Kutoka kwa mtazamo wa kiufundi, maombi yanajumuisha huduma ndogo tatu, ambayo kila moja hutatua seti fulani ya matatizo:

• SA-Frontend ni seva ya wavuti ya Nginx inayotoa faili tuli za React.
• SA-WebApp ni programu ya wavuti iliyoandikwa katika Java ambayo hushughulikia maombi kutoka kwa sehemu ya mbele.
• SA-Logic ni programu ya Python ambayo hufanya uchambuzi wa hisia kwenye maandishi.

Ni muhimu kutambua kwamba microservices haipo kwa pekee. Wanatekeleza wazo la "mgawanyo wa majukumu", lakini wakati huo huo wanahitaji kuingiliana na kila mmoja.

Data hutiririka katika programu

Katika mchoro hapo juu, unaweza kuona hatua zilizohesabiwa za mfumo, zinazoonyesha mtiririko wa data katika programu. Hebu tuwaangalie:

1. Kivinjari huomba faili kutoka kwa seva index.html (ambayo, kwa upande wake, hupakua kifurushi cha programu ya React).
2. Mtumiaji huingiliana na programu, hii husababisha simu kwa programu ya wavuti inayotegemea Spring.
3. Programu ya wavuti inatuma ombi la kufanya uchambuzi wa maandishi kwa programu ya Python.
4. Programu ya Python hufanya uchambuzi wa hisia za maandishi na kurudisha matokeo kama jibu la ombi.
5. Programu ya Spring hutuma jibu kwa programu ya React (ambayo, kwa upande wake, inaonyesha matokeo ya uchambuzi wa maandishi kwa mtumiaji).

Msimbo wa programu hizi zote unaweza kupatikana hapa. Ninapendekeza kwamba unakili hazina hii kwako sasa hivi, kwa kuwa kuna majaribio mengi ya kuvutia nayo mbele yetu.

Kuendesha programu-msingi ya huduma ndogo kwenye mashine yako ya karibu

Ili programu ifanye kazi, tunahitaji kuanza huduma ndogo zote tatu. Wacha tuanze na bora zaidi - programu ya mbele.

▍ Sanidi React kwa maendeleo ya ndani

Ili kuendesha programu ya React, unahitaji kusakinisha jukwaa la Node.js na NPM kwenye kompyuta yako. Mara tu baada ya kusanikisha haya yote, tumia terminal kwenda kwenye folda yako ya mradi sa-frontend na endesha amri ifuatayo:

npm install

Kwa kuendesha amri hii kwenye folda node_modules utegemezi wa programu ya React utapakiwa, rekodi ambazo ziko kwenye faili package.json. Mara tu utegemezi unapopakuliwa kwenye folda moja, endesha amri ifuatayo:

npm start

Ni hayo tu. Sasa programu ya React inaendeshwa, unaweza kuipata kwa kwenda kwa anwani ifuatayo kwenye kivinjari chako: localhost:3000. Unaweza kubadilisha kitu katika msimbo wake. Utaona mara moja athari za mabadiliko haya kwenye kivinjari. Hii inawezekana shukrani kwa kinachojulikana kama "moto" badala ya moduli. Hii inafanya maendeleo ya mbele kuwa uzoefu rahisi na wa kufurahisha.

▍Kutayarisha programu ya React kwa ajili ya uzalishaji

Kwa madhumuni ya kutumia programu ya React, tunahitaji kuibadilisha kuwa seti ya faili tuli na kuzihudumia kwa wateja wanaotumia seva ya wavuti.

Ili kuunda programu ya React, tena kwa kutumia terminal, nenda kwenye folda sa-frontend na endesha amri ifuatayo:

npm run build

Hii itaunda saraka kwenye folda ya mradi build. Itakuwa na faili zote tuli zinazohitajika ili programu ya React iendeshe.

▍Inatoa faili tuli kwa kutumia Nginx

Kwanza unahitaji kusakinisha na kuendesha seva ya wavuti ya Nginx. Hapa unaweza kuipakua na kupata maagizo ya jinsi ya kusakinisha na kuiendesha. Kisha unahitaji kunakili yaliyomo kwenye folda sa-frontend/build kwa folda [your_nginx_installation_dir]/html.

Kwa mbinu hii, faili iliyotolewa wakati wa mchakato wa ujenzi wa programu ya React index.html itapatikana kwa [your_nginx_installation_dir]/html/index.html. Hii ndio faili ambayo, kwa chaguo-msingi, seva ya Nginx hutoa wakati wa kuipata. Seva imesanidiwa kusikiliza kwenye mlango 80, lakini inaweza kubinafsishwa kwa njia unayohitaji kwa kuhariri faili [your_nginx_installation_dir]/conf/nginx.conf.

Sasa fungua kivinjari chako na uende localhost:80. Utaona ukurasa wa programu ya React.

Programu ya React inayotolewa na seva ya Nginx

Ikiwa sasa unaingiza kitu kwenye shamba Type your sentence na bonyeza kitufe Send - hakuna kitakachotokea. Lakini, ukiangalia koni, unaweza kuona ujumbe wa makosa hapo. Ili kuelewa ni wapi hasa makosa haya hutokea, hebu tuchambue msimbo wa maombi.

▍Uchanganuzi wa msimbo wa programu ya mbele

Kuangalia msimbo wa faili App.js, tunaweza kuona kwamba kubonyeza kitufe Send wito mbinu analyzeSentence(). Kanuni ya mbinu hii imetolewa hapa chini. Tafadhali kumbuka kuwa kwa kila mstari ambao una maoni ya fomu # Номер, kuna maelezo yaliyotolewa chini ya kanuni. Tutachambua vipande vingine vya kanuni kwa njia ile ile.

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 ambayo ombi la POST linafanywa. Inachukuliwa kuwa kuna maombi katika anwani hii ambayo yanatarajia maombi kama haya.

2.Mwili wa ombi ulitumwa kwa maombi. Hapa kuna mfano wa mwili wa ombi:

{
    sentence: "I like yogobella!"
}

3.Wakati jibu la ombi linapokelewa, hali ya sehemu inasasishwa. Hii husababisha kipengele kutolewa tena. Tukipokea data (yaani, kitu cha JSON kilicho na data ya ingizo na alama ya maandishi yaliyokokotolewa), tutatoa kijenzi hicho. Polarity, kwa kuwa masharti yanayofaa yatafikiwa. Hivi ndivyo tunavyoelezea sehemu:

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

Nambari inaonekana kufanya kazi vizuri. Ni nini kibaya na hii, hata hivyo? Ikiwa unadhania kuwa katika anwani ambayo programu inajaribu kutuma ombi la POST, hakuna kitu ambacho kinaweza kukubali na kushughulikia ombi hili, basi utakuwa sahihi kabisa. Yaani, kushughulikia maombi yaliyopokelewa kwa http://localhost:8080/sentiment, tunahitaji kuendesha programu ya wavuti kulingana na Spring.

Tunahitaji programu ya Spring ambayo inaweza kukubali ombi la POST

▍Kusanidi programu ya wavuti kulingana na Spring

Ili kupeleka programu ya Spring, utahitaji JDK8 na Maven na anuwai za mazingira zilizosanidiwa vizuri. Mara baada ya kusanikisha haya yote, unaweza kuendelea kufanya kazi kwenye mradi wetu.

▍Kupakia programu kwenye faili ya jar

Nenda, kwa kutumia terminal, kwenye folda sa-webapp na ingiza amri ifuatayo:

mvn install

Baada ya kuendesha amri hii kwenye folda sa-webapp saraka itaundwa target. Hapa ndipo programu ya Java itapatikana, iliyowekwa kwenye faili ya jar, iliyowakilishwa na faili sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Kuendesha programu ya Java

Nenda kwenye folda target na endesha programu kwa amri ifuatayo:

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

Hitilafu itatokea wakati wa kutekeleza amri hii. Ili kuanza kuirekebisha, tunaweza kuchanganua maelezo ya ubaguzi katika data ya ufuatiliaji wa rafu:

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

Kwa sisi, jambo muhimu zaidi hapa ni kutajwa kwa kutowezekana kwa kufafanua maana sa.logic.api.url. Hebu tuchambue msimbo ambao kosa hutokea.

▍Uchanganuzi wa msimbo wa programu ya Java

Hapa kuna kijisehemu cha msimbo ambapo kosa linatokea.

@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. Katika SentimentController kuna shamba saLogicApiUrl. Thamani yake imebainishwa na mali sa.logic.api.url.
2. Kamba saLogicApiUrl inaambatana na thamani /analyse/sentiment. Kwa pamoja huunda anwani ya kupiga simu kwa huduma ndogo ambayo hufanya uchambuzi wa maandishi.

▍Weka thamani ya sifa

Katika chemchemi, chanzo cha kawaida cha maadili ya mali ni faili application.properties, ambayo inaweza kupatikana kwa sa-webapp/src/main/resources. Lakini matumizi yake sio njia pekee ya kuweka maadili ya mali. Hii inaweza pia kufanywa kwa kutumia amri ifuatayo:

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

Thamani ya mali hii inapaswa kuelekeza kwa anwani ya programu yetu ya Python.

Kwa kuisanidi, tunaambia programu ya wavuti ya Spring ambapo inahitaji kwenda kutekeleza maombi ya uchanganuzi wa maandishi.

Ili sio kutatanisha maisha yetu, tutaamua kuwa programu ya Python itapatikana localhost:5000 na hebu jaribu kusahau kuhusu hilo. Kama matokeo, amri ya kuzindua programu ya Spring itaonekana kama hii:

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

Mfumo wetu unakosa programu ya Python

Sasa tunachopaswa kufanya ni kuendesha programu ya Python na mfumo utafanya kazi kama inavyotarajiwa.

▍Kusanidi programu ya Python

Ili kuendesha programu ya Python, lazima uwe na Python 3 na Pip iliyosanikishwa, na anuwai za mazingira zinazofaa lazima ziwekwe kwa usahihi.

▍Kusakinisha vitegemezi

Nenda kwenye folda ya mradi wako sa-logic/sa na endesha amri zifuatazo:

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

▍Zindua programu

Baada ya kusakinisha vitegemezi, tuko tayari kuendesha programu:

python sentiment_analysis.py

Baada ya kutekeleza amri hii tutaambiwa yafuatayo:

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

Hii ina maana kwamba programu inaendeshwa na inasubiri maombi saa localhost:5000/

▍ Utafiti wa Kanuni

Wacha tuangalie nambari ya maombi ya Python ili kuelewa jinsi inavyojibu maombi:

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. Kuanzisha kitu Flask.
2. Inabainisha anwani ya kutekeleza maombi ya POST kwake.
3. Kurejesha Mali sentence kutoka kwa shirika la ombi.
4. Kuanzisha Kipengee Kisichojulikana TextBlob na kupata thamani polarity kwa hukumu ya kwanza iliyopokelewa katika mwili wa ombi (kwa upande wetu, hii ndiyo hukumu pekee iliyotumwa kwa uchambuzi).
5. Kurejesha jibu ambalo mwili wake una maandishi ya sentensi na kiashirio kilichohesabiwa kwake polarity.
6. Zindua programu ya Flask, ambayo itapatikana saa 0.0.0.0:5000 (unaweza pia kuipata kwa kutumia muundo wa fomu localhost:5000).

Huduma ndogo ndogo zinazounda programu sasa zinafanya kazi. Wao ni tuned kuingiliana na kila mmoja. Hivi ndivyo mchoro wa maombi unavyoonekana katika hatua hii ya kazi.

Huduma ndogo ndogo zote zinazounda programu huletwa kwa utaratibu wa kufanya kazi

Sasa, kabla ya kuendelea, fungua programu yako ya React katika kivinjari na ujaribu kuchanganua sentensi nayo. Ikiwa kila kitu kimefanywa kwa usahihi - baada ya kushinikiza kifungo Send utaona matokeo ya uchambuzi chini ya uga wa maandishi.

Katika sehemu inayofuata, tutazungumza juu ya jinsi ya kuendesha huduma zetu ndogo kwenye vyombo vya Docker. Hii ni muhimu ili kuandaa programu ya kufanya kazi kwenye nguzo ya Kubernetes.

Vyombo vya Docker

Mabernet ni mfumo wa kusambaza otomatiki, kuongeza na usimamizi wa programu zilizo na vyombo. Pia inaitwa "orchestrator ya chombo". Ikiwa Kubernetes inafanya kazi na vyombo, basi kabla ya kutumia mfumo huu lazima kwanza tupate vyombo hivi. Lakini kwanza, hebu tuzungumze juu ya vyombo ni nini. Labda jibu bora kwa swali la ni nini linaweza kupatikana ndani nyaraka kwa Docker:

Picha ya chombo ni kifurushi chepesi, kinachojitosheleza, kinachoweza kutekelezeka kilicho na programu, ambacho kinajumuisha kila kitu muhimu ili kuiendesha: nambari ya programu, mazingira ya utekelezaji, zana za mfumo na maktaba, mipangilio. Programu zilizowekwa kwenye vyombo zinaweza kutumika katika mazingira ya Linux na Windows, na zitafanya kazi sawa kila wakati bila kujali miundombinu.

Hii ina maana kwamba vyombo vinaweza kuendeshwa kwenye kompyuta yoyote, ikiwa ni pamoja na seva za uzalishaji, na programu zilizomo ndani yake zitafanya kazi sawa katika mazingira yoyote.

Ili kuchunguza vipengele vya vyombo na kulinganisha na njia nyingine za kuendesha programu, hebu tuangalie mfano wa kutumikia programu ya React kwa kutumia mashine pepe na kontena.

▍Inatoa faili tuli za programu ya React kwa kutumia mashine pepe

Kujaribu kupanga huduma ya faili tuli kwa kutumia mashine za kawaida, tutakutana na hasara zifuatazo:

1. Matumizi yasiyofaa ya rasilimali, kwani kila mashine ya kawaida ni mfumo kamili wa kufanya kazi.
2. Utegemezi wa jukwaa. Kinachofanya kazi kwenye kompyuta ya ndani huenda kisifanye kazi kwenye seva ya uzalishaji.
3. Kuongeza polepole na kwa rasilimali nyingi kwa suluhisho la msingi la mashine.

Seva ya wavuti ya Nginx inayohudumia faili tuli zinazoendeshwa kwenye mashine pepe

Ikiwa vyombo vinatumiwa kutatua shida kama hiyo, basi, kwa kulinganisha na mashine halisi, nguvu zifuatazo zinaweza kuzingatiwa:

1. Matumizi bora ya rasilimali: kufanya kazi na mfumo wa uendeshaji kwa kutumia Docker.
2. Jukwaa la kujitegemea. Chombo ambacho msanidi programu anaweza kuendesha kwenye kompyuta yake kitafanya kazi popote.
3. Usambazaji mwepesi kupitia matumizi ya tabaka za picha.

Seva ya wavuti ya Nginx inayohudumia faili tuli zinazoendesha kwenye kontena

Tulilinganisha mashine na kontena pepe kwenye nukta chache tu, lakini hata hii inatosha kupata hisia kwa uwezo wa vyombo. Hapa Unaweza kupata maelezo juu ya vyombo vya Docker.

▍Kuunda picha ya kontena kwa ajili ya programu ya React

Msingi wa ujenzi wa chombo cha Docker ni faili Dockerfile. Mwanzoni mwa faili hii, rekodi inafanywa kwa picha ya msingi ya chombo, basi kuna mlolongo wa maagizo yanayoonyesha jinsi ya kuunda chombo ambacho kitakidhi mahitaji ya programu fulani.

Kabla ya kuanza kufanya kazi na faili Dockerfile, tukumbuke tulichofanya kuandaa faili za programu ya React kwa kupakiwa kwenye seva ya Nginx:

1. Kuunda kifurushi cha programu ya React (npm run build).
2. Kuanzisha seva ya Nginx.
3. Kunakili yaliyomo kwenye saraka build kutoka kwa folda ya mradi sa-frontend kwa folda ya seva nginx/html.

Hapo chini unaweza kuona ulinganifu kati ya kuunda kontena na hatua zilizo hapo juu zilizofanywa kwenye kompyuta yako ya karibu.

▍Kutayarisha faili ya Docker kwa ajili ya programu ya SA-Frontend

Maagizo ambayo yatajumuishwa ndani Dockerfile kwa maombi SA-Frontend, inajumuisha timu mbili tu. Ukweli ni kwamba timu ya maendeleo ya Nginx imeandaa msingi picha kwa Nginx, ambayo tutatumia kuunda picha yetu. Hizi ndizo hatua mbili tunazohitaji kuelezea:

1. Msingi wa picha inapaswa kuwa picha ya Nginx.
2. Yaliyomo kwenye Folda sa-frontend/build zinahitaji kunakiliwa kwenye folda ya picha nginx/html.

Ukitoka kwenye maelezo haya hadi kwenye faili Dockerfile, basi itaonekana kama hii:

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

Kama unaweza kuona, kila kitu hapa ni rahisi sana, na yaliyomo kwenye faili hata yanageuka kuwa ya kusomeka na kueleweka. Faili hii inauambia mfumo kuchukua picha nginx na kila kitu ambacho tayari kiko ndani yake, na unakili yaliyomo kwenye saraka build kwa saraka nginx/html.

Hapa unaweza kuwa na swali kuhusu jinsi ninavyojua ni wapi unahitaji kunakili faili kutoka kwa folda build, yaani, njia ilitoka wapi /usr/share/nginx/html. Kwa kweli, hakuna chochote ngumu hapa ama. Ukweli ni kwamba habari inayofaa inaweza kupatikana ndani maelezo picha.

▍Kuunda picha na kuipakia kwenye hazina

Kabla ya kufanya kazi na picha iliyokamilishwa, tunahitaji kuisukuma kwenye hifadhi ya picha. Ili kufanya hivyo, tutatumia jukwaa la bure la mwenyeji wa picha ya wingu Docker Hub. Katika hatua hii ya kazi unahitaji kufanya yafuatayo:

1. Ili kufunga Docker.
2. Jiandikishe kwenye wavuti ya Docker Hub.
3. Ingia kwa akaunti yako kwa kutekeleza amri ifuatayo kwenye terminal:

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

Sasa unahitaji kutumia terminal kwenda kwenye saraka sa-frontend na endesha amri ifuatayo hapo:

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

Hapa na zaidi katika amri zinazofanana $DOCKER_USER_ID inapaswa kubadilishwa na jina lako la mtumiaji la Docker Hub. Kwa mfano, sehemu hii ya amri inaweza kuonekana kama hii: rinormaloku/sentiment-analysis-frontend.

Katika kesi hii, amri hii inaweza kufupishwa kwa kuiondoa -f Dockerfile, kwa kuwa faili hii tayari iko kwenye folda ambayo tunatekeleza amri hii.

Ili kutuma picha iliyokamilishwa kwenye ghala, tunahitaji amri ifuatayo:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Baada ya kuikamilisha, angalia orodha ya hazina zako kwenye Docker Hub ili kuelewa ikiwa upakiaji wa picha kwenye hifadhi ya wingu ulifanikiwa.

▍Kuendesha chombo

Sasa mtu yeyote anaweza kupakua na kuendesha picha, inayojulikana kama $DOCKER_USER_ID/sentiment-analysis-frontend. Ili kufanya hivyo, unahitaji kuendesha mlolongo ufuatao wa amri:

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

Sasa chombo kinaendelea, tunaweza kuendelea kufanya kazi kwa kuunda picha zingine tunazohitaji. Lakini kabla ya kuendelea, hebu tuelewe muundo 80:80, ambayo inaonekana katika amri ya uzinduzi wa picha na inaweza kuonekana kuwa na utata.

• Nambari ya kwanza 80 - hii ndio nambari ya bandari mwenyeji (yaani, kompyuta ya ndani).
• Nambari ya pili 80 ni bandari ya kontena ambalo ombi linapaswa kutumwa.

Fikiria kielezi kifuatacho.

Usambazaji wa Bandari

Mfumo huelekeza upya maombi kutoka kwa bandari <hostPort> hadi bandarini <containerPort>. Hiyo ni, upatikanaji wa bandari 80 kompyuta inaelekezwa kwenye bandari 80 chombo.

Tangu bandari 80 kufunguliwa kwenye kompyuta ya ndani, kisha unaweza kufikia programu kutoka kwa kompyuta hii localhost:80. Ikiwa mfumo wako hauungi mkono Docker, programu inaweza kuendeshwa kwenye mashine ya kawaida ya Docker, ambayo anwani yake itaonekana kama <docker-machine ip>:80. Ili kujua anwani ya IP ya mashine ya kawaida ya Docker, unaweza kutumia amri docker-machine ip.

Katika hatua hii, baada ya kuzindua kwa ufanisi kontena la programu ya mbele, unapaswa kuwa na uwezo wa kufungua ukurasa wake kwenye kivinjari.

▍Faili ya .dockerignore

Inakusanya picha ya programu SA-Frontend, tunaweza kugundua kuwa mchakato huu unageuka kuwa wa polepole sana. Hii hutokea kwa sababu muktadha wa kujenga picha lazima utumwe kwa daemon ya Docker. Saraka inayowakilisha muktadha wa ujenzi imebainishwa kama hoja ya mwisho ya amri docker build. Kwa upande wetu, kuna nukta mwishoni mwa amri hii. Hii inasababisha muundo ufuatao kujumuishwa katika muktadha wa ujenzi:

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

Lakini kati ya folda zote zilizopo hapa, tunahitaji folda tu build. Kupakia kitu kingine chochote ni kupoteza muda. Unaweza kuharakisha ujenzi kwa kumwambia Docker ni saraka gani za kupuuza. Ni ili kufanya hivyo tunahitaji faili .dockerignore. Wewe, ikiwa unaifahamu faili .gitignore, muundo wa faili hii labda utaonekana kuwa wa kawaida. Inaorodhesha saraka ambazo mfumo wa kujenga picha unaweza kupuuza. Kwa upande wetu, yaliyomo kwenye faili hii yanaonekana kama hii:

node_modules
src
public

file .dockerignore lazima iwe kwenye folda sawa na faili Dockerfile. Sasa kujenga picha itachukua suala la sekunde.

Wacha tufanye kazi kwenye picha ya programu ya Java.

▍Kuunda picha ya kontena kwa programu ya Java

Unajua nini, tayari umejifunza kila kitu unachohitaji kujua ili kuunda picha za kontena. Ndiyo maana sehemu hii itakuwa fupi sana.

Fungua faili Dockerfileambayo iko kwenye folda ya mradi sa-webapp. Ikiwa unasoma maandishi ya faili hii, utaona miundo miwili tu mpya ndani yake, kuanzia na maneno ENV и EXPOSE:

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

Neno kuu ENV Inakuruhusu kutangaza anuwai za mazingira ndani ya vyombo vya Docker. Hasa, kwa upande wetu, inakuwezesha kutaja URL ili kufikia API ya programu ambayo hufanya uchambuzi wa maandishi.

Neno kuu EXPOSE hukuruhusu kumwambia Docker kufungua bandari. Tutatumia mlango huu tunapoendesha programu. Hapa unaweza kugundua kuwa ndani Dockerfile kwa maombi SA-Frontend hakuna amri kama hiyo. Hii ni kwa madhumuni ya nyaraka tu, kwa maneno mengine, ujenzi huu unalenga kwa yule atakayesoma Dockerfile.

Kuunda picha na kuisukuma kwenye hazina inaonekana sawa na katika mfano uliopita. Ikiwa bado huna ujasiri sana katika uwezo wako, amri zinazofanana zinaweza kupatikana kwenye faili README.md kwenye folda sa-webapp.

▍Kuunda picha ya kontena kwa programu ya Python

Ukiangalia yaliyomo kwenye faili Dockerfile kwenye folda sa-logic, basi hutapata chochote kipya kwako mwenyewe huko. Amri za kuunda picha na kuituma kwa hazina inapaswa pia kujulikana kwako, lakini, kama ilivyo kwa programu zetu zingine, zinaweza kupatikana kwenye faili. README.md kwenye folda sa-logic.

▍Kujaribu programu zilizowekwa

Je, unaweza kuamini kitu ambacho hujakifanyia majaribio? Siwezi pia. Hebu tujaribu vyombo vyetu.

1. Hebu tuzindue chombo cha maombi sa-logic na uisanidi ili isikilize kwenye bandari 5050:

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

2. Hebu tuzindue chombo cha maombi sa-webapp na uisanidi ili isikilize kwenye bandari 8080. Kwa kuongezea, tunahitaji kusanidi bandari ambayo programu ya Python itasikiliza maombi kutoka kwa programu ya Java kwa kugawa upya utofauti wa mazingira. 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

Ili kujifunza jinsi ya kujua anwani ya IP ya chombo cha Docker au mashine ya kawaida, rejelea faili README.

Hebu tuzindue chombo cha maombi sa-frontend:

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

Sasa kila kitu kiko tayari kwenda kwa anwani kwenye kivinjari localhost:80 na ujaribu maombi.

Tafadhali kumbuka kuwa ikiwa ulibadilisha bandari kwa sa-webapp, au ikiwa unaendesha mashine ya kawaida ya Docker, utahitaji kuhariri faili App.js kutoka kwa folda sa-frontendkwa kubadilisha anwani ya IP au nambari ya bandari katika mbinu analyzeSentence(), kubadilisha maelezo ya sasa badala ya data iliyopitwa na wakati. Baada ya hayo, unahitaji kuunganisha tena picha na kuitumia.

Hivi ndivyo mchoro wetu wa programu unavyoonekana sasa.

Huduma ndogo huendeshwa kwenye vyombo

Muhtasari: kwa nini tunahitaji nguzo ya Kubernetes?

Tumechunguza faili hivi punde Dockerfile, alizungumza juu ya jinsi ya kuunda picha na kuzisukuma kwenye hazina ya Docker. Kwa kuongeza, tulijifunza jinsi ya kuharakisha mkusanyiko wa picha kwa kutumia faili .dockerignore. Kwa hivyo, huduma zetu ndogo sasa zinaendeshwa kwenye vyombo vya Docker. Hapa unaweza kuwa na swali la haki kabisa kuhusu kwa nini tunahitaji Kubernetes. Sehemu ya pili ya nyenzo hii itajitolea kujibu swali hili. Wakati huo huo, fikiria swali lifuatalo:
Wacha tuchukue kuwa programu yetu ya wavuti ya uchanganuzi wa maandishi imekuwa maarufu ulimwenguni. Mamilioni ya maombi huja kwake kila dakika. Hii ina maana kwamba microservices sa-webapp и sa-logic itakuwa chini ya mzigo mkubwa. Jinsi ya kuongeza vyombo vinavyoendesha huduma ndogo?

Chanzo: mapenzi.com