Kubernetes Tutoriala 1. zatia: aplikazioak, mikrozerbitzuak eta edukiontziak

Gure eskariz, Habr-ek hub bat sortu zuen Kubernetes eta pozik jartzen dugu bertan lehen argitalpena. Harpidetu!

Kubernetes erraza da. Zergatik ordaintzen didate bankuek diru asko arlo honetan lan egiteko, edonork teknologia hau ordu gutxitan menderatu dezakeen bitartean?

Kubernetes hain azkar ikas daitekeela zalantza baduzu, zuk zeuk egiten saiatzea gomendatzen dizut. Hots, material hau menperatu ondoren, mikrozerbitzuetan oinarritutako aplikazio bat exekutatu ahal izango duzu Kubernetes kluster batean. Hori berma dezaket, zeren eta hemen erabiltzen dudan metodologia berean irakasten diet gure bezeroei Kubernetesekin nola lan egin. Zerk bereizten du gida hau besteengandik? Egia esan, gauza asko. Beraz, material horietako gehienak gauza sinpleen azalpenarekin hasten dira: Kubernetes-en kontzeptuak eta kubectl komandoaren ezaugarriak. Artikulu hauen egileek bere irakurleak aplikazioen garapena, mikrozerbitzuak eta Docker edukiontziak ezagutzen dituela uste dute. Beste bide batetik joango gara. Lehenik eta behin, hitz egin dezagun ordenagailu batean mikrozerbitzuetan oinarritutako aplikazio bat nola exekutatu. Ondoren, mikrozerbitzu bakoitzerako edukiontzien irudiak eraikitzea aztertuko dugu. Eta horren ostean, Kubernetes ezagutu eta mikrozerbitzuetan oinarritutako aplikazio baten hedapena aztertuko dugu Kubernetes-ek kudeatutako kluster batean.

Ikuspegi honek, Kubernetesera pixkanaka hurbilduz, batez besteko pertsonak behar duen zer gertatzen den ulertzeko sakontasuna emango du Kubernetesen dena nola antolatuta dagoen ulertzeko. Kubernetes, zalantzarik gabe, teknologia sinplea da, baldin eta menderatu nahi duenak badaki non eta nola erabiltzen den.

Orain, gehiagorik gabe, ekin diezaiogun lanari eta hitz egingo diogu lanean arituko garen aplikazioari buruz.

Aplikazio esperimentala

Gure aplikazioak funtzio bakarra beteko du. Sarrera gisa esaldi bat hartzen du, eta ondoren, testuak aztertzeko tresnak erabiliz, esaldi horren sentimendu-analisia egiten du, esaldiaren egileak objektu jakin baten aurrean duen jarrera emozionalaren balorazioa lortuz.

Hau da aplikazio honen leiho nagusiaren itxura.

Sentimenduen Azterketa Web Aplikazioa

Ikuspuntu teknikotik, aplikazioak hiru mikrozerbitzuk osatzen dute, eta horietako bakoitzak zeregin multzo jakin bat ebazten du:

• SA-Frontend React fitxategi estatikoak zerbitzatzen dituen Nginx web zerbitzari bat da.
• SA-WebApp Javan idatzitako web aplikazio bat da, frontend-eko eskaerak kudeatzen dituena.
• SA-Logic Python aplikazio bat da, testu-sentimenduen azterketa egiten duena.

Garrantzitsua da mikrozerbitzuak ez direla isolatuta existitzen. "Betebeharrak bereizteko" ideia inplementatzen dute, baina, aldi berean, elkarreragin behar dute.

Datu-fluxuak aplikazioan

Goiko diagraman, sistemaren fase zenbakituak ikus ditzakezu, aplikazioko datu-fluxuak irudikatuz. Bana ditzagun:

1. Arakatzaileak fitxategi bat eskatzen dio zerbitzariari index.html (horrek, aldi berean, React aplikazioaren paketea kargatzen du).
2. Erabiltzaileak aplikazioarekin elkarreragin egiten du, honek Spring-en oinarritutako web aplikazio baterako deia eragiten du.
3. Web aplikazioak testua analizatzeko eskaera Python aplikaziora birbidaltzen du.
4. Python aplikazioak testuaren sentimendua aztertzen du eta emaitza itzultzen du eskaeraren erantzun gisa.
5. Spring aplikazioak erantzun bat bidaltzen dio React aplikazioari (horrek, aldi berean, analizatutako testuaren emaitza erakusten dio erabiltzaileari).

Aplikazio hauen guztien kodea aurki daiteke Hemen. Biltegi hau zurekin kopiatzea gomendatzen dizut oraintxe bertan, esperimentu interesgarri asko baitaude aurretik.

Mikrozerbitzuetan oinarritutako aplikazio bat exekutatzea tokiko makinan

Aplikazioak funtziona dezan, hiru mikrozerbitzuak martxan jarri behar ditugu. Has gaitezen politenekin: front-end aplikazioarekin.

▍Tokiko garapenerako React abian jartzea

React aplikazio bat exekutatzeko, Node.js markoa eta NPM instalatu behar dituzu zure ordenagailuan. Hau guztia instalatu ondoren, joan terminala erabiliz proiektuaren karpetara sa-frontend eta exekutatu komando hau:

npm install

Komando hau karpetan exekutatuz node_modules React aplikazioaren menpekotasunak kargatuko dira, eta horien erregistroak fitxategian daude package.json. Menpekotasunak karpeta berean deskargatu ondoren, exekutatu komando hau:

npm start

Hori da dena. React aplikazioa martxan dago eta arakatzailearen helbidera nabigatuz sar daiteke localhost:3000. Bere kodean zerbait alda dezakezu. Aldaketa hauen eragina berehala ikusiko duzu arakatzailean. Hori posible da moduluen ordezkapen "beroa" delakoari esker. Horri esker, front-end garapena esperientzia sinple eta atsegina bihurtzen da.

▍React aplikazioa ekoizpenerako prestatzea

React aplikazioa benetan erabiltzeko, fitxategi estatiko multzo batean bihurtu behar dugu eta web zerbitzari bat erabiliz bezeroei zerbitzatu.

React aplikazioa eraikitzeko, berriro terminala erabiliz, joan karpetara sa-frontend eta exekutatu komando hau:

npm run build

Honek direktorio bat sortuko du proiektuaren karpetan build. React aplikazioak funtziona dezan beharrezkoak diren fitxategi estatiko guztiak edukiko ditu.

▍Fitxategi estatikoak Nginx-ekin hornitzea

Lehenik eta behin, Nginx web zerbitzaria instalatu eta exekutatu behar duzu. Hemen deskargatu eta instalatu eta exekutatzeko argibideak aurki ditzakezu. Ondoren, karpetaren edukia kopiatu behar duzu sa-frontend/build karpetara [your_nginx_installation_dir]/html.

Planteamendu honekin, React aplikazioaren muntaketan sortutako fitxategia index.html helbidean egongo da eskuragarri [your_nginx_installation_dir]/html/index.html. Hau da, lehenespenez, Nginx zerbitzariak bertara sartzean igortzen duen fitxategia. Zerbitzaria ataka batean entzuteko konfiguratuta dago 80, baina nahi duzun moduan pertsonaliza dezakezu fitxategia editatuz [your_nginx_installation_dir]/conf/nginx.conf.

Orain ireki zure arakatzailea eta joan hona localhost:80. React aplikazioaren orria ikusiko duzu.

Nginx zerbitzariak eskaintzen duen React aplikazioa

Orain eremuan zerbait sartzen baduzu Type your sentence eta sakatu botoia Send - ez da ezer gertatuko. Baina, kontsolara begiratuz gero, errore-mezuak ikus ditzakezu bertan. Akats horiek non gertatzen diren zehatz-mehatz ulertzeko, azter dezagun aplikazioaren kodea.

▍Frontend aplikazioaren kodearen analisia

Fitxategiaren kodeari begira App.js, hori botoian klik eginda ikus dezakegu Send metodo bat deitzen du analyzeSentence(). Metodo honen kodea behean erakusten da. Aldi berean, kontutan izan inprimakiaren iruzkin bat dagoen lerro bakoitzeko # Номер, kodearen azpian ematen den azalpena dago. Modu berean, beste kode zati batzuk analizatuko ditugu.

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. POST eskaera egiten zaion URLa. Helbide hau eskaera horien zain dagoen aplikazio bat dela suposatzen da.

2.Eskaera organoa bidalitako eskaera. Hona hemen eskaeraren gorputz adibide bat:

{
    sentence: "I like yogobella!"
}

3.Eskaera baten erantzuna jasotzen denean, osagaiaren egoera eguneratzen da. Honek osagaia berriro errendatzea eragiten du. Datuak jasotzen baditugu (hau da, sartutako datuak eta kalkulatutako testuaren puntuazioa dituen JSON objektu bat), osagaia aterako dugu. Polaritybetiere, baldintzak betetzen badira. Hona hemen osagaia nola deskribatzen dugun:

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

Kodeak nahiko ondo funtzionatzen duela dirudi. Zer dago gaizki hemen, hala ere? Aplikazioak POST eskaera bat bidaltzen saiatzen ari den helbidean oraindik eskaera hau onartu eta prozesatu dezakeen ezer ez dagoela uste baduzu, arrazoi osoa izango duzu. Alegia, helbidera datozen eskaerak tramitatzeko http://localhost:8080/sentiment, Spring-en oinarritutako web aplikazio bat exekutatu behar dugu.

POST eskaera onar dezakeen Spring aplikazio bat behar dugu

▍Udaberrian oinarritutako web aplikazio bat konfiguratzea

Spring aplikazio bat zabaltzeko, JDK8 eta Maven eta behar bezala konfiguratutako ingurune-aldagaiak behar dituzu. Hau guztia instalatu ondoren, gure proiektuan lanean jarrai dezakezu.

▍Aplikazioa jar fitxategi batean ontziratzea

Nabigatu, terminala erabiliz, karpetara sa-webapp eta sartu komando hau:

mvn install

Komando hau karpetan exekutatu ondoren sa-webapp direktorioa sortuko da target. Bertan kokatuko da Java aplikazioa, jar fitxategi batean bilduta, fitxategiak irudikatuta sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Java aplikazio bat abiarazi

Joan karpetara target eta exekutatu aplikazioa komando honekin:

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

Errore bat gertatuko da komando hau exekutatzen ari zaren bitartean. Konpontzen hasteko, salbuespenen xehetasunak analizatu ditzakegu pilaren arrastoaren datuetan:

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

Guretzat, hemen garrantzitsuena esanahia argitu ezinaren aipamena da sa.logic.api.url. Azter dezagun errorea non gertatzen den kodea.

▍Java aplikazioaren kodearen azterketa

Hona hemen errorea gertatzen den kode zatia.

@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. S.-nentimentController eremu bat dago saLogicApiUrl. Bere balioa jabetzak ezartzen du sa.logic.api.url.
2. ilara saLogicApiUrl balioarekin kateatzen da /analyse/sentiment. Elkarrekin testu-analisia egiten duen mikrozerbitzuari dei bat egiteko helbide bat osatzen dute.

▍Jabetza-balioa ezartzea

Udaberrian, jabetza-balioen iturri lehenetsia fitxategi bat da application.properties, helbidean aurki daitekeena sa-webapp/src/main/resources. Baina erabiltzea ez da jabetza-balioak ezartzeko modu bakarra. Hau ere egin dezakezu komando honekin:

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

Propietate honen balioak gure Python aplikazioaren helbidea adierazi beharko luke.

Konfiguratuz, Spring web aplikazioari nondik joan behar duen esaten diogu testuak analizatzeko eskaerak egiteko.

Gure bizitza ez zailtzeko, Python aplikazioa hemen eskuragarri egongo dela erabakiko dugu localhost:5000 eta saiatu ez ahazten. Ondorioz, Spring aplikazioa abiarazteko komandoak itxura hau izango du:

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

Gure sistemari Python aplikazio bat falta zaio

Orain Python aplikazioa exekutatu besterik ez dugu eta sistemak espero bezala funtzionatuko du.

▍Python aplikazio bat konfiguratzea

Python aplikazio bat exekutatzeko, Python 3 eta Pip instalatuta izan behar dituzu, eta ingurune-aldagai egokiak behar bezala ezarrita izan behar dituzu.

▍Menpekotasunak instalatu

Joan proiektuaren karpetara sa-logic/sa eta exekutatu komando hauek:

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

▍Aplikazioa abiarazteko

Mendekotasunak instalatuta, aplikazioa exekutatzeko prest gaude:

python sentiment_analysis.py

Komando hau exekutatu ondoren, honako hau esango zaigu:

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

Horrek esan nahi du aplikazioa exekutatzen ari dela eta eskaerak zain daudela localhost:5000/

▍Kodeen ikerketa

Ikus dezagun Python aplikazioaren kodea eskaerei nola erantzuten dien ulertzeko:

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. Objektuen hasieratzea Flask.
2. POST eskaerak egiteko helbidea zehaztea.
3. Jabetza bat berreskuratzea sentence eskaera-organotik.
4. Objektu anonimoaren hasieratzea TextBlob eta balioa lortzea polarity eskaeraren gorputzean jasotako lehen proposamenerako (gure kasuan, hori da aztertzeko aurkeztu den proposamen bakarra).
5. Erantzun bat itzultzea, zeinaren gorputzean eskaintzaren testua eta horretarako kalkulatutako adierazlea polarity.
6. Helbide honetan eskuragarri egongo den Flask aplikazioa abian jartzea 0.0.0.0:5000 (inprimakiaren eraikuntza bat erabiliz ere sar zaitezke localhost:5000).

Orain aplikazioa osatzen duten mikrozerbitzuak martxan daude. Elkarren artean elkarreragiteko ezarrita daude. Hona hemen aplikazioaren diagrama lanaren fase honetan nolakoa den.

Aplikazioa osatzen duten mikrozerbitzu guztiak egoera osasuntsu batera eramaten dira

Orain, jarraitu aurretik, ireki React aplikazioa arakatzaile batean eta saiatu harekin esaldiren bat analizatzen. Dena behar bezala egiten bada - botoia sakatu ondoren Send analisiaren emaitzak testu-koadroaren azpian ikusiko dituzu.

Hurrengo atalean, gure mikrozerbitzuak Docker edukiontzietan nola exekutatu buruz hitz egingo dugu. Hau beharrezkoa da aplikazioa Kubernetes klusterrean exekutatzeko prestatzeko.

Docker edukiontziak

Kubernetes edukiontzidun aplikazioen hedapena, eskalatzea eta kudeaketa automatizatzeko sistema bat da. "Edukiontzien orkestratzailea" ere deitzen zaio. Kubernetes-ek edukiontziekin lan egiten badu, sistema hau erabili aurretik, edukiontzi hauek eskuratu behar ditugu. Baina lehenik eta behin, hitz egin dezagun zer diren edukiontziak. Agian zer den galderaren erantzunik onena aurki daiteke dokumentazioa Docker-era:

Edukiontziaren irudia pakete arin, autonomo eta exekutagarri bat da, aplikazio bat daukana, hura exekutatzeko beharrezkoa den guztia barne hartzen duena: aplikazioaren kodea, exekuzio-ingurunea, sistema-tresnak eta liburutegiak, ezarpenak. Edukiontzidun programak Linux zein Windows inguruneetan erabil daitezke eta beti berdin funtzionatuko dute azpiegitura edozein dela ere.

Horrek esan nahi du edukiontziak edozein ordenagailutan exekutatu daitezkeela, ekoizpen zerbitzarietan barne, eta edozein ingurunetan, horietan dauden aplikazioek berdin funtzionatuko dute.

Edukiontzien ezaugarriak arakatzeko eta aplikazioak exekutatzeko beste modu batzuekin alderatzeko, ikus dezagun React aplikazio bat makina birtual bat eta edukiontzi bat erabiliz zerbitzatzeko adibidea.

▍React aplikazio baten fitxategi estatikoak zerbitzatzea makina birtual bat erabiliz

Fitxategi estatikoen mantentze-lanak makina birtualak erabiliz antolatu nahian, honako desabantaila hauek izango ditugu:

1. Baliabideen erabilera ez eraginkorra, makina birtual bakoitza sistema eragile osoa baita.
2. Plataformaren menpekotasuna. Tokiko ordenagailu batzuetan funtzionatzen duena agian ez da funtzionatuko ekoizpen-zerbitzari batean.
3. Makina birtualaren soluzio baten eskalatze motela eta baliabide intentsiboa.

Nginx web zerbitzaria makina birtualean exekutatzen diren fitxategi estatikoak zerbitzatzen ditu

Antzeko arazo bat konpontzeko edukiontziak erabiltzen badira, orduan, makina birtualekin alderatuta, honako indargune hauek nabarmen daitezke:

1. Baliabideen erabilera eraginkorra: Docker erabiliz sistema eragilearekin lan egin.
2. Plataformaren independentzia. Garatzaile batek bere ordenagailuan exekutatu dezakeen edukiontzi bat edonon exekutatzen da.
3. Inplementazio arina irudi geruzak erabiliz.

Nginx web zerbitzaria edukiontzi batean exekutatzen diren fitxategi estatikoak zerbitzatzen ditu

Makina birtualak eta edukiontziak puntu batzuetan baino ez ditugu alderatu, baina hori ere nahikoa da edukiontzien indarguneak ezagutzeko. Hemen Docker edukiontziei buruzko xehetasunak aurki ditzakezu.

▍React aplikazio baterako edukiontzi-irudia sortzea

Docker edukiontzi baten oinarrizko eraikuntza-blokea fitxategia da Dockerfile. Fitxategi honen hasieran, edukiontziaren oinarrizko irudi bat grabatzen da, ondoren aplikazio baten beharrei erantzungo dien edukiontzi bat nola sortu adieraziz jarraibide-sekuentzia bat sartzen da.

Fitxategiarekin lanean hasi aurretik Dockerfile, gogoratu zer egin genuen React aplikazioaren fitxategiak Nginx zerbitzarira igotzeko prestatzeko:

1. React aplikazio pakete bat eraikitzea (npm run build).
2. Nginx zerbitzaria abiarazten.
3. Direktorio baten edukia kopiatzea build proiektuaren karpetatik sa-frontend zerbitzariaren karpetara nginx/html.

Jarraian edukiontzi bat sortzearen eta tokiko ordenagailuan egindako goiko ekintzen arteko paralelismoak ikus ditzakezu.

▍Dockerfile bat prestatzea SA-Frontend aplikaziorako

Bertan sartu beharreko argibideak Dockerfile aplikaziorako SA-Frontend, bi talde bakarrik osatuta. Kontua da Nginx garapen taldeak oinarrizko bat prestatu duela irudia Nginx-entzat, gure irudia eraikitzeko erabiliko duguna. Hona hemen deskribatu behar ditugun bi urratsak:

1. Nginx irudia irudiaren oinarri bihurtu behar duzu.
2. Karpetaren edukia sa-frontend/build irudien karpetara kopiatu behar duzu nginx/html.

Deskribapen honetatik fitxategira pasatzen bagara Dockerfile, orduan itxura hau izango du:

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

Ikus dezakezunez, hemen dena oso erraza da, fitxategiaren edukia nahiko irakurgarria eta ulergarria dela ere. Fitxategi honek sistemari irudia hartzeko esaten dio nginx lehendik duen guztiarekin, eta kopiatu direktorioko edukiak build direktoriora nginx/html.

Hemen galdera bat izan dezakezu nola dakidan karpetako fitxategiak zehazki non kopiatu build, hau da, nondik atera zen bidea /usr/share/nginx/html. Izan ere, hemen ere ez dago ezer konplikaturik. Kontua da informazio garrantzitsua hemen aurki daitekeela deskribapena irudia.

▍ Irudia muntatu eta biltegira igotzea

Osatutako irudi batekin lan egin aurretik, irudi biltegira bidali behar dugu. Horretarako, Docker Hub doako hodeian oinarritutako irudiak ostatatzeko plataforma erabiliko dugu. Lanaren fase honetan, honako hau egin behar duzu:

1. ezarri Docker.
2. Eman izena Docker Hub gunean.
3. Hasi saioa zure kontuan komando hau terminalean exekutatuz:

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

Orain, terminala erabiliz, direktoriora joan behar duzu sa-frontend eta exekutatu komando hau bertan:

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

Hemen eta behean antzeko komandoetan $DOCKER_USER_ID Docker Hub-en zure erabiltzaile-izenarekin ordezkatu behar da. Adibidez, komandoaren zati hau honelakoa izan daiteke: rinormaloku/sentiment-analysis-frontend.

Kasu honetan, komando hau laburtu daiteke bertatik kenduz -f Dockerfile, komando hau exekutatzen dugun karpetak dagoeneko fitxategi hau dauka.

Amaitutako irudia biltegira bidaltzeko, komando hau behar dugu:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Osatu ondoren, egiaztatu zure biltegien zerrenda Docker Hub-en irudia hodeiko biltegira behar bezala eraman den ikusteko.

▍Edukiontzi bat martxan jartzea

Orain edonork deskargatu eta exekutatu dezake izenez ezagutzen den irudia $DOCKER_USER_ID/sentiment-analysis-frontend. Horretarako, komando-sekuentzia hau exekutatu behar duzu:

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

Orain edukiontzia martxan dago, eta lanean jarraitu dezakegu behar ditugun beste irudi batzuk sortuz. Baina jarraitu baino lehen, uler dezagun diseinua 80:80, irudia exekutatzeko komandoan aurkitzen dena eta nahasia dirudi.

• Lehenengo zenbakia 80 ostalariaren ataka-zenbakia da (hau da, tokiko ordenagailua).
• Bigarren zenbakia 80 eskaera birbideratu behar den edukiontziaren ataka da.

Demagun hurrengo ilustrazioa.

Portuak bidaltzea

Sistemak portuko eskaerak birbidaltzen ditu <hostPort> portura <containerPort>. Hau da, portura sartzea 80 ordenagailua ataka batera birbideratzen da 80 edukiontzia.

Portutik 80 tokiko ordenagailuan irekita, aplikaziora sartu zaitezke ordenagailu honetatik helbidean localhost:80. Zure sistemak Docker onartzen ez badu, aplikazioa Docker makina birtual batean exekutatu dezakezu, honen helbidea itxura izango du. <docker-machine ip>:80. Docker makina birtualaren IP helbidea ezagutzeko, komandoa erabil dezakezu docker-machine ip.

Une honetan, frontend aplikazioaren edukiontzia behar bezala abiarazi ondoren, bere orria arakatzaile batean ireki ahal izango zenuke.

▍.dockerignore fitxategia

Aplikazioaren irudia eraikitzea SA-Frontend, prozesu hau oso motela dela nabaritu genezake. Irudia eraikitzeko testuingurua Docker deabrura bidali behar delako gertatzen da. Eraikitze-testuingurua adierazten duen direktorioa komandoaren azken argumentu gisa ematen da docker build. Gure kasuan, komando honen amaieran puntu bat dago. Honen ondorioz, egitura hau muntaketa testuinguruan sartzen da:

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

Baina hemen dauden karpeta guztietatik, karpeta bat besterik ez dugu behar build. Beste edozer deskargatzea denbora galtzea da. Eraikuntza bizkortu dezakezu Dockerri zein direktorio baztertu behar dituen esanez. Horretarako, fitxategi bat behar dugu .dockerignore. Zuk, fitxategia ezagutzen baduzu .gitignore, ziurrenik fitxategi honen egitura ezaguna izango da. Irudiak sortzeko sistemak baztertu ditzakeen direktorioak zerrendatzen ditu. Gure kasuan, fitxategi honen edukia honelakoa da:

node_modules
src
public

fitxategia .dockerignore fitxategiaren karpeta berean egon behar du Dockerfile. Orain irudiaren muntaketak segundo batzuk beharko ditu.

Jo dezagun orain Java aplikazio baten irudia.

▍Java aplikazio baterako edukiontzi-irudia sortzea

Badakizu zer, eta dagoeneko ikasi duzu edukiontzien irudiak sortzeko behar duzun guztia. Horregatik atal hau oso laburra izango da.

Ireki fitxategia Dockerfile, proiektuaren karpetan dagoena sa-webapp. Fitxategi honen testua irakurtzen baduzu, gako-hitzekin hasten diren bi eraikuntza berri baino ez dituzu ezagutuko ENV и EXPOSE:

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

Hitz gakoa ENV Docker edukiontzien barruan ingurune-aldagaiak deklaratzeko aukera ematen du. Bereziki, gure kasuan, testu-analisia egiten duen aplikazioaren APIra sartzeko URL bat ezartzeko aukera ematen du.

Hitz gakoa EXPOSE Dockerri ataka bat irekitzeko esateko aukera ematen dizu. Aplikazioarekin lan egiten dugun heinean ataka hau erabiliko dugu. Hemen ikus dezakezu hori Dockerfile aplikaziorako SA-Frontend ez dago halako agindurik. Hau dokumentazio helburuetarako soilik da, hau da, eraikuntza hau irakurlearentzat da Dockerfile.

Irudia eraikitzea eta biltegira bultzatzea aurreko adibidearen antzekoa da. Oraindik zure gaitasunetan oso ziur ez bazaude, dagozkien komandoak fitxategian aurki daitezke README.md karpetan sa-webapp.

▍Python aplikazio baterako edukiontzi-irudi bat sortzea

Fitxategiaren edukiari begirada bat ematen badiozu Dockerfile karpetan sa-logicez duzu ezer berririk aurkituko hor. Irudia eraikitzeko eta biltegira bultzatzeko komandoak ezagunak izan beharko litzaizuke dagoeneko, baina, gure gainerako aplikazioen kasuan bezala, fitxategian aurki daitezke. README.md karpetan sa-logic.

▍Edukiontzidun aplikazioak probatzea

Fida al zaitezke probatu ez duzun zerbaitetan? Nik ere ezin dut. Proba ditzagun gure ontziak.

1. Hasi gaitezen aplikazioaren edukiontzia sa-logic eta konfiguratu ataka batean entzuteko 5050:

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

2. Hasi gaitezen aplikazioaren edukiontzia sa-webapp eta konfiguratu ataka batean entzuteko 8080. Horrez gain, Python aplikazioak Java aplikazioaren eskaerak entzungo dituen ataka ezarri behar dugu ingurune aldagaia berriro esleituz. 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

Edukiontzi edo Docker VM baten IP helbidea nola jakin jakiteko, ikusi fitxategia README.

Hasi gaitezen aplikazioaren edukiontzia sa-frontend:

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

Orain dena prest dago nabigatzailean helbidera nabigatzeko localhost:80 eta probatu aplikazioa.

Kontuan izan ataka aldatzen baduzu sa-webapp, edo Docker VM bat exekutatzen ari bazara, fitxategia editatu beharko duzu App.js karpetatik sa-frontendmetodoan IP helbidea edo ataka zenbakia aldatuz analyzeSentence()egungo informazioa ordezkatuz, zaharkitutako datuen ordez. Horren ondoren, irudia berriro muntatu eta erabili behar duzu.

Hau da gure aplikazioaren diagrama orain.

Mikrozerbitzuak edukiontzietan exekutatzen dira

Laburpena: zergatik behar dugu Kubernetes kluster bat?

Fitxategiak berrikusi berri ditugu Dockerfile, irudiak nola eraiki eta Docker biltegira nola bultzatu hitz egin zuen. Horrez gain, fitxategia erabiliz irudien muntaketa bizkortu ikasi dugu .dockerignore. Ondorioz, gure mikrozerbitzuak Docker edukiontzietan exekutatzen ari dira. Hemen guztiz justifikatutako galdera bat izan dezakezu Kubernetes zergatik behar dugun jakiteko. Galdera honen erantzuna material honen bigarren zatiari eskainiko zaio. Bitartean, kontuan hartu galdera hau:
Demagun gure testuak aztertzeko web aplikazioa mundu osoan ezaguna bihurtu dela. Milioika eskaera heltzen zaizkio minuturo. Horrek esan nahi du mikrozerbitzuak sa-webapp и sa-logic estres izugarria izango da. Nola eskalatu mikrozerbitzuak exekutatzen dituzten edukiontziak?

Iturria: www.habr.com