🥇Kubernetes ceļveža 1. daļa: lietojumprogrammas, mikropakalpojumi un konteineri

Pēc mūsu pieprasījuma Habrs izveidoja centru Kubernetes un mēs esam priecīgi tajā ievietot pirmo publikāciju. Abonējiet!

Kubernetes ir viegli. Kāpēc bankas man maksā lielu naudu, lai strādātu šajā jomā, kamēr ikviens var apgūt šo tehnoloģiju tikai dažu stundu laikā?

Ja šaubāties, ka Kubernetes var tik ātri apgūt, iesaku pamēģināt pašam. Proti, apgūstot šo materiālu, varēsi palaist uz mikropakalpojumiem balstītu aplikāciju Kubernetes klasterī. Es to varu garantēt, jo tieši ar to pašu metodiku, kas tiek izmantota šeit, es mācu mūsu klientiem strādāt ar Kubernetes. Ar ko šī rokasgrāmata atšķiras no citām? Patiesībā ir daudz lietu. Tātad lielākā daļa šo materiālu sākas ar vienkāršu lietu skaidrojumu - Kubernetes jēdzieniem un komandas kubectl iezīmēm. Šo materiālu autori pieņem, ka viņu lasītāji pārzina lietojumprogrammu izstrādi, mikropakalpojumus un Docker konteinerus. Mēs iesim citu ceļu. Pirmkārt, mēs runāsim par to, kā datorā palaist lietojumprogrammu, kuras pamatā ir mikropakalpojumi. Pēc tam apskatīsim katra mikropakalpojuma konteinera attēlu izveidi. Un pēc tam mēs iepazīsimies ar Kubernetes un apskatīsim uz mikropakalpojumiem balstītas lietojumprogrammas izvietošanu Kubernetes pārvaldītajā klasterī.

Šī pieeja ar pakāpenisku pieeju Kubernetes sniegs notiekošā izpratnes dziļumu, kas nepieciešams vidusmēra cilvēkam, lai saprastu, kā Kubernetes vienkārši viss darbojas. Kubernetes noteikti ir vienkārša tehnoloģija, ja tie, kas vēlas to apgūt, zina, kur un kā tā tiek izmantota.

Tagad, bez papildu piepūles, sāksim un runāsim par lietojumprogrammu, ar kuru mēs strādāsim.

Eksperimentāls pielietojums

Mūsu lietojumprogramma veiks tikai vienu funkciju. Par ievadi tiek ņemts viens teikums, pēc kura, izmantojot teksta analīzes rīkus, tiek veikta šī teikuma sentimenta analīze, iegūstot novērtējumu teikuma autora emocionālajai attieksmei pret noteiktu objektu.

Šādi izskatās šīs lietojumprogrammas galvenais logs.

Tīmekļa lietojumprogramma tekstu sentimenta analīzei

No tehniskā viedokļa lietojumprogramma sastāv no trim mikropakalpojumiem, no kuriem katrs atrisina noteiktu problēmu kopumu:

SA-Frontend ir Nginx tīmekļa serveris, kas apkalpo statiskus React failus.
SA-WebApp ir Java valodā rakstīta tīmekļa lietojumprogramma, kas apstrādā pieprasījumus no priekšgala.
SA-Logic ir Python lietojumprogramma, kas veic teksta sentimenta analīzi.

Ir svarīgi atzīmēt, ka mikropakalpojumi nepastāv atsevišķi. Viņi īsteno ideju par "pienākumu nodalīšanu", bet tajā pašā laikā viņiem ir jāsadarbojas vienam ar otru.

Datu plūsmas lietojumprogrammā

Iepriekš redzamajā diagrammā var redzēt numurētos sistēmas posmus, kas ilustrē datu plūsmas lietojumprogrammā. Apskatīsim tos:

Pārlūkprogramma pieprasa failu no servera index.html (kas savukārt lejupielādē React lietojumprogrammas pakotni).
Lietotājs mijiedarbojas ar lietojumprogrammu, un tas izraisa izsaukumu uz pavasara tīmekļa lietojumprogrammu.
Tīmekļa lietojumprogramma pārsūta pieprasījumu veikt teksta analīzi Python lietojumprogrammai.
Python lietojumprogramma veic teksta sentimenta analīzi un atgriež rezultātu kā atbildi uz pieprasījumu.
Lietojumprogramma Spring nosūta atbildi uz React aplikāciju (kas savukārt parāda lietotājam teksta analīzes rezultātu).

Visu šo lietojumprogrammu kodu var atrast šeit. Es iesaku jums tūlīt nokopēt šo krātuvi, jo mums ar to ir daudz interesantu eksperimentu.

Uz mikropakalpojumiem balstītas lietojumprogrammas palaišana vietējā datorā

Lai lietojumprogramma darbotos, mums ir jāstartē visi trīs mikropakalpojumi. Sāksim ar jaukāko no tiem — priekšgala lietojumprogrammu.

▍Izveidojiet React vietējai attīstībai

Lai palaistu React lietojumprogrammu, datorā jāinstalē platforma Node.js un NPM. Kad tas viss ir instalēts, izmantojiet termināli, lai pārietu uz savu projekta mapi sa-frontend un palaidiet šādu komandu:

npm install

Palaižot šo komandu mapē node_modules tiks ielādētas React aplikācijas atkarības, kuru ieraksti atrodas failā package.json. Kad atkarības ir lejupielādētas tajā pašā mapē, palaidiet šo komandu:

npm start

Tas ir viss. Tagad darbojas lietojumprogramma React, tai varat piekļūt, pārlūkprogrammā dodoties uz šo adresi: localhost:3000. Jūs varat kaut ko mainīt tā kodā. Jūs uzreiz redzēsit šo izmaiņu ietekmi pārlūkprogrammā. Tas ir iespējams, pateicoties tā sauktajai “karsto” moduļu nomaiņai. Tas padara priekšgala izstrādi par vienkāršu un patīkamu pieredzi.

▍React pieteikuma sagatavošana ražošanai

Lai faktiski izmantotu React lietojumprogrammu, mums tā ir jāpārvērš par statisku failu kopu un jāpasniedz klientiem, izmantojot tīmekļa serveri.

Lai izveidotu lietojumprogrammu React, vēlreiz izmantojot termināli, dodieties uz mapi sa-frontend un palaidiet šādu komandu:

npm run build

Tādējādi projekta mapē tiks izveidots direktorijs build. Tajā būs visi statiskie faili, kas nepieciešami, lai programma React darbotos.

▍Statisko failu apkalpošana, izmantojot Nginx

Vispirms jums jāinstalē un jāpalaiž Nginx tīmekļa serveris. Šeit varat to lejupielādēt un atrast instrukcijas, kā to instalēt un palaist. Pēc tam jums ir jākopē mapes saturs sa-frontend/build uz mapi [your_nginx_installation_dir]/html.

Izmantojot šo pieeju, fails tiek ģenerēts lietojumprogrammas React veidošanas procesā index.html būs pieejams plkst [your_nginx_installation_dir]/html/index.html. Šis ir fails, ko pēc noklusējuma Nginx serveris rada, piekļūstot tam. Serveris ir konfigurēts, lai klausītos portā 80, taču to var pielāgot vajadzīgajā veidā, rediģējot failu [your_nginx_installation_dir]/conf/nginx.conf.

Tagad atveriet pārlūkprogrammu un dodieties uz localhost:80. Jūs redzēsit React pieteikuma lapu.

Reaģēt lietojumprogrammu, ko apkalpo Nginx serveris

Ja tagad kaut ko ievadīsi laukā Type your sentence un nospiediet pogu Send - nekas nenotiks. Bet, ja paskatās uz konsoli, jūs varat redzēt kļūdu ziņojumus. Lai saprastu, kur tieši rodas šīs kļūdas, analizēsim lietojumprogrammas kodu.

▍ Priekšējās lietojumprogrammas koda analīze

Apskatiet faila kodu App.js, mēs to redzam, nospiežot pogu Send sauc metodi analyzeSentence(). Šīs metodes kods ir norādīts zemāk. Lūdzu, ņemiet vērā, ka katrai rindai, kurā ir veidlapas komentārs # Номер, zem koda ir sniegts paskaidrojums. Tādā pašā veidā mēs analizēsim citus koda fragmentus.

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. URL, uz kuru tiek nosūtīts POST pieprasījums. Tiek pieņemts, ka šajā adresē ir pieteikums, kas gaida šādus pieprasījumus.

2.Pieprasījuma iestāde nosūtīta pieteikumam. Šeit ir pieprasījuma pamatteksta piemērs:

{
    sentence: "I like yogobella!"
}

3.Kad tiek saņemta atbilde uz pieprasījumu, komponenta stāvoklis tiek atjaunināts. Tas izraisa komponenta atkārtotu renderēšanu. Ja mēs saņemam datus (tas ir, JSON objektu, kurā ir ievades dati un aprēķinātais teksta rezultāts), mēs izvadīsim komponentu Polarity, jo tiks izpildīti attiecīgie nosacījumi. Šādi mēs aprakstām komponentu:

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

Šķiet, ka kods darbojas diezgan labi. Kas ar to ir nepareizi? Ja pieņemat, ka adresē, uz kuru aplikācija mēģina nosūtīt POST pieprasījumu, vēl nekas nevar pieņemt un apstrādāt šo pieprasījumu, tad jums būs pilnīga taisnība. Proti, lai apstrādātu pieprasījumus, kas saņemti plkst http://localhost:8080/sentiment, mums ir jāpalaiž tīmekļa lietojumprogramma, kuras pamatā ir pavasaris.

Mums ir nepieciešama pavasara lietojumprogramma, kas var pieņemt POST pieprasījumu

▍ Pavasarī balstītas tīmekļa lietojumprogrammas iestatīšana

Lai izvietotu Spring lietojumprogrammu, jums būs nepieciešami JDK8 un Maven un pareizi konfigurēti vides mainīgie. Kad tas viss ir instalēts, varat turpināt darbu pie mūsu projekta.

▍Lietojumprogrammas iesaiņošana jar failā

Izmantojot termināli, dodieties uz mapi sa-webapp un ievadiet šādu komandu:

mvn install

Pēc šīs komandas palaišanas mapē sa-webapp tiks izveidots direktorijs target. Šeit atradīsies Java lietojumprogramma, kas ir iepakota jar failā, ko attēlo fails sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Palaižot Java lietojumprogrammu

Dodieties uz mapi target un palaidiet lietojumprogrammu ar šādu komandu:

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

Šīs komandas izpildes laikā radīsies kļūda. Lai sāktu to labot, mēs varam analizēt izņēmuma informāciju steka izsekošanas datos:

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

Mums šeit vissvarīgākā ir nozīmes noskaidrošanas neiespējamības pieminēšana sa.logic.api.url. Analizēsim kodu, kurā rodas kļūda.

▍Java lietojumprogrammas koda analīze

Šeit ir koda fragments, kurā rodas kļūda.

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

In SentimentController ir lauks saLogicApiUrl. Tā vērtību nosaka īpašums sa.logic.api.url.
String saLogicApiUrl savienojas ar vērtību /analyse/sentiment. Kopā tie veido adresi zvanīšanai uz mikropakalpojumu, kas veic teksta analīzi.

▍Iestatiet īpašuma vērtību

Pavasarī standarta īpašuma vērtību avots ir fails application.properties, ko var atrast vietnē sa-webapp/src/main/resources. Bet tā izmantošana nav vienīgais veids, kā noteikt īpašuma vērtības. To var izdarīt arī, izmantojot šādu komandu:

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

Šī īpašuma vērtībai ir jānorāda uz mūsu Python lietojumprogrammas adresi.

Konfigurējot to, mēs norādām Spring tīmekļa lietojumprogrammai, kur tai ir jāiet, lai veiktu teksta analīzes pieprasījumus.

Lai neapgrūtinātu mūsu dzīvi, nolemsim, ka Python aplikācija būs pieejama plkst localhost:5000 un centīsimies par to neaizmirst. Rezultātā lietojumprogrammas Spring palaišanas komanda izskatīsies šādi:

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

Mūsu sistēmā trūkst Python lietojumprogrammas

Tagad atliek tikai palaist Python lietojumprogrammu, un sistēma darbosies kā paredzēts.

▍Python lietojumprogrammas iestatīšana

Lai palaistu Python lietojumprogrammu, ir jābūt instalētai Python 3 un Pip, kā arī pareizi jāiestata atbilstošie vides mainīgie.

▍Atkarību instalēšana

Dodieties uz sava projekta mapi sa-logic/sa un palaidiet šādas komandas:

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

▍Palaidiet lietojumprogrammu

Pēc atkarību instalēšanas mēs esam gatavi palaist lietojumprogrammu:

python sentiment_analysis.py

Pēc šīs komandas palaišanas mums tiks paziņots:

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

Tas nozīmē, ka lietojumprogramma darbojas un gaida pieprasījumus plkst localhost:5000/

▍Koda izpēte

Apskatīsim Python lietojumprogrammas kodu, lai saprastu, kā tas reaģē uz pieprasījumiem:

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

Objekta inicializācija Flask.
Adreses norādīšana POST pieprasījumu veikšanai tai.
Īpašuma izgūšana sentence no pieprasījuma iestādes.
Anonīma objekta inicializācija TextBlob un iegūt vērtību polarity par pirmo teikumu, kas saņemts pieprasījuma pamattekstā (mūsu gadījumā šis ir vienīgais teikums, kas nosūtīts analīzei).
Atgriežot atbildi, kuras pamatteksts satur teikuma tekstu un tam aprēķināto rādītāju polarity.
Palaidiet lietojumprogrammu Flask, kas būs pieejama vietnē 0.0.0.0:5000 (tai var piekļūt arī, izmantojot veidlapas konstrukciju localhost:5000).

Mikropakalpojumi, kas veido lietojumprogrammu, tagad darbojas. Viņi ir pielāgoti mijiedarbībai savā starpā. Šādi izskatās pielietojuma diagramma šajā darba posmā.

Visi mikropakalpojumi, kas veido lietojumprogrammu, ir sakārtoti darba kārtībā

Tagad, pirms turpināt, atveriet savu React lietojumprogrammu pārlūkprogrammā un mēģiniet ar to parsēt kādu teikumu. Ja viss ir izdarīts pareizi - pēc pogas nospiešanas Send jūs redzēsit analīzes rezultātus zem teksta lauka.

Nākamajā sadaļā mēs runāsim par to, kā darbināt mūsu mikropakalpojumus Docker konteineros. Tas ir nepieciešams, lai sagatavotu lietojumprogrammu darbam Kubernetes klasterī.

Dokeru konteineri

Kubernetes ir sistēma konteinerizētu lietojumprogrammu izvietošanas, mērogošanas un pārvaldības automatizēšanai. To sauc arī par "konteineru orķestrētāju". Ja Kubernetes strādā ar konteineriem, tad pirms šīs sistēmas lietošanas mums vispirms ir jāiegādājas šie konteineri. Bet vispirms parunāsim par to, kas ir konteineri. Iespējams, ka vislabākā atbilde uz jautājumu, kas tas ir, ir atrodama dokumentācija uz Docker:

Konteinera attēls ir viegls, pašpietiekams, izpildāms pakotne, kas satur lietojumprogrammu, kurā iekļauts viss nepieciešamais tās palaišanai: lietojumprogrammas kods, izpildlaika vide, sistēmas rīki un bibliotēkas, kā arī iestatījumi. Konteinerizētas programmas var izmantot vidēs Linux и Windows, un tie vienmēr darbosies vienādi neatkarīgi no infrastruktūras.

Tas nozīmē, ka konteinerus var darbināt jebkurā datorā, arī ražošanas serveros, un tajos esošās lietojumprogrammas darbosies vienādi jebkurā vidē.

Lai izpētītu konteineru funkcijas un salīdzinātu tos ar citiem lietojumprogrammu palaišanas veidiem, apskatīsim piemēru par React lietojumprogrammas apkalpošanu, izmantojot virtuālo mašīnu un konteineru.

▍React lietojumprogrammas statisko failu apkalpošana, izmantojot virtuālo mašīnu

Mēģinot organizēt statisko failu apkalpošanu, izmantojot virtuālās mašīnas, mēs saskarsimies ar šādiem trūkumiem:

Neefektīva resursu izmantošana, jo katra virtuālā mašīna ir pilnvērtīga operētājsistēma.
Platformas atkarība. Tas, kas darbojas lokālajā datorā, var nedarboties ražošanas serverī.
Lēna un resursietilpīga uz virtuālās mašīnas balstīta risinājuma mērogošana.

Nginx tīmekļa serveris, kas apkalpo statiskus failus, kas darbojas virtuālajā mašīnā

Ja līdzīgas problēmas risināšanai tiek izmantoti konteineri, tad, salīdzinot ar virtuālajām mašīnām, var atzīmēt šādas stiprās puses:

Efektīva resursu izmantošana: darbs ar operētājsistēmu, izmantojot Docker.
Platformas neatkarīga. Konteiners, ko izstrādātājs var darbināt savā datorā, darbosies jebkur.
Viegla izvietošana, izmantojot attēla slāņus.

Nginx tīmekļa serveris, kas apkalpo statiskus failus, kas darbojas konteinerā

Mēs salīdzinājām virtuālās mašīnas un konteinerus tikai dažos punktos, taču pat ar to pietiek, lai izjustu konteineru stiprās puses. Šeit Jūs varat atrast sīkāku informāciju par Docker konteineriem.

▍Konteinera attēla izveide React lietojumprogrammai

Docker konteinera pamatelements ir fails Dockerfile. Šī faila sākumā tiek izveidots konteinera pamattēla ieraksts, pēc tam seko instrukciju secība, kas norāda, kā izveidot konteineru, kas atbilstu noteiktas lietojumprogrammas vajadzībām.

Pirms sākam strādāt ar failu Dockerfile, atcerēsimies, ko mēs darījām, lai sagatavotu React lietojumprogrammas failus augšupielādei Nginx serverī:

React lietojumprogrammas pakotnes izveide (npm run build).
Nginx servera palaišana.
Kataloga satura kopēšana build no projekta mapes sa-frontend uz servera mapi nginx/html.

Tālāk varat redzēt paralēles starp konteinera izveidi un iepriekš minētajām darbībām, kas veiktas jūsu lokālajā datorā.

▍Dokera faila sagatavošana SA-Frontend lietojumprogrammai

Norādījumi, kas tiks ietverti Dockerfile pieteikumam SA-Frontend, sastāv tikai no divām komandām. Fakts ir tāds, ka Nginx izstrādes komanda ir sagatavojusi pamata attēls priekš Nginx, ko izmantosim sava tēla izveidošanai. Šīs ir divas darbības, kas mums jāapraksta:

Attēla pamatā jābūt Nginx attēlam.
Mapes saturs sa-frontend/build jākopē attēlu mapē nginx/html.

Ja pāriesit no šī apraksta uz failu Dockerfile, tad tas izskatīsies šādi:

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

Kā redzat, šeit viss ir ļoti vienkārši, un faila saturs pat izrādās diezgan lasāms un saprotams. Šis fails liek sistēmai uzņemt attēlu nginx ar visu, kas tajā jau atrodas, un kopējiet direktorijas saturu build uz direktoriju nginx/html.

Šeit jums var rasties jautājums par to, kā es zinu, kur tieši jums ir nepieciešams kopēt failus no mapes build, tas ir, no kurienes nāca ceļš /usr/share/nginx/html. Patiesībā arī šeit nav nekā sarežģīta. Fakts ir tāds, ka attiecīgo informāciju var atrast apraksts attēls.

▍Izveidojiet attēlu un augšupielādējiet to repozitorijā

Lai mēs varētu strādāt ar gatavo attēlu, mums tas ir jāievieto attēlu krātuvē. Lai to izdarītu, mēs izmantosim bezmaksas mākoņa attēlu mitināšanas platformu Docker Hub. Šajā darba posmā jums jāveic šādas darbības:

Instalēt dokers.
Reģistrējieties Docker Hub vietnē.
Piesakieties savā kontā, terminālī izpildot šādu komandu:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Tagad jums ir jāizmanto terminālis, lai pārietu uz direktoriju sa-frontend un palaidiet tur šādu komandu:

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

Šeit un tālāk līdzīgās komandās $DOCKER_USER_ID jāaizstāj ar jūsu Docker Hub lietotājvārdu. Piemēram, šī komandas daļa varētu izskatīties šādi: rinormaloku/sentiment-analysis-frontend.

Šajā gadījumā šo komandu var saīsināt, noņemot no tās -f Dockerfile, jo šis fails jau pastāv mapē, kurā mēs izpildām šo komandu.

Lai gatavo attēlu nosūtītu uz repozitoriju, mums ir nepieciešama šāda komanda:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Pēc tā pabeigšanas pārbaudiet savu repozitoriju sarakstu Docker Hub, lai saprastu, vai attēla augšupielāde mākoņa krātuvē bija veiksmīga.

▍Palaižot konteineru

Tagad ikviens var lejupielādēt un palaist attēlu, kas pazīstams kā $DOCKER_USER_ID/sentiment-analysis-frontend. Lai to izdarītu, jums ir jāpalaiž šāda komandu secība:

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

Tagad konteiners darbojas, mēs varam turpināt darbu, veidojot citus mums nepieciešamos attēlus. Bet pirms turpinām, sapratīsim dizainu 80:80, kas parādās attēla palaišanas komandā un var šķist mulsinoši.

Pirmais numurs 80 — tas ir resursdatora porta numurs (tas ir, lokālā datora).
Otrais numurs 80 ir konteinera osta, uz kuru jānosūta pieprasījums.

Apsveriet tālāk sniegto ilustrāciju.

Portu pārsūtīšana

Sistēma pāradresē pieprasījumus no porta <hostPort> uz ostu <containerPort>. Tas ir, pieeja ostai 80 dators tiek novirzīts uz portu 80 konteiners.

Kopš ostas 80 atvērts lokālajā datorā, varat piekļūt lietojumprogrammai no šī datora vietnē localhost:80. Ja jūsu sistēma neatbalsta Docker, lietojumprogrammu var palaist Docker virtuālajā mašīnā, kuras adrese izskatīsies šādi <docker-machine ip>:80. Lai uzzinātu Docker virtuālās mašīnas IP adresi, varat izmantot komandu docker-machine ip.

Šajā brīdī pēc veiksmīgas priekšgala lietojumprogrammas konteinera palaišanas jums vajadzētu būt iespējai pārlūkprogrammā atvērt tā lapu.

▍.dockerignore fails

Lietojumprogrammas attēla apkopošana SA-Frontend, mēs varējām pamanīt, ka šis process izrādās ārkārtīgi lēns. Tas notiek tāpēc, ka attēla izveides konteksts ir jānosūta Docker dēmonam. Direktorijs, kas pārstāv būvēšanas kontekstu, ir norādīts kā pēdējais komandas arguments docker build. Mūsu gadījumā šīs komandas beigās ir punkts. Tādējādi būvniecības kontekstā tiek iekļauta šāda struktūra:

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

Bet no visām šeit esošajām mapēm mums ir nepieciešama tikai mape build. Kaut ko citu ielādēšana ir laika izšķiešana. Varat paātrināt veidošanu, norādot Docker, kurus direktorijus ignorēt. Lai to izdarītu, mums ir nepieciešams fails .dockerignore. Jūs, ja esat iepazinies ar failu .gitignore, šī faila struktūra, iespējams, šķitīs pazīstama. Tajā ir uzskaitīti direktoriji, kurus attēla veidošanas sistēma var ignorēt. Mūsu gadījumā šī faila saturs izskatās šādi:

node_modules
src
public

fails .dockerignore jāatrodas tajā pašā mapē, kur fails Dockerfile. Tagad attēla izveide prasīs dažas sekundes.

Tagad strādāsim pie Java lietojumprogrammas attēla.

▍Konteinera attēla izveide Java lietojumprogrammai

Jūs jau esat iemācījušies visu, kas jums jāzina, lai izveidotu konteinera attēlus. Tāpēc šī sadaļa būs ļoti īsa.

Atveriet failu Dockerfilekas atrodas projekta mapē sa-webapp. Izlasot šī faila tekstu, tajā redzēsiet tikai divas jaunas konstrukcijas, sākot ar atslēgvārdiem ENV и EXPOSE:

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

Atslēgvārds ENV Ļauj deklarēt vides mainīgos Docker konteineros. Jo īpaši mūsu gadījumā tas ļauj norādīt URL, lai piekļūtu lietojumprogrammas API, kas veic teksta analīzi.

Atslēgvārds EXPOSE ļauj norādīt Docker atvērt portu. Lietojumprogrammas palaišanas laikā mēs izmantosim šo portu. Šeit jūs to varat pamanīt Dockerfile pieteikumam SA-Frontend tādas komandas nav. Tas ir tikai dokumentācijas nolūkos, citiem vārdiem sakot, šī konstrukcija ir paredzēta tam, kurš lasīs Dockerfile.

Attēla izveide un nosūtīšana uz repozitoriju izskatās tieši tāpat kā iepriekšējā piemērā. Ja vēl neesat ļoti pārliecināts par savām spējām, atbilstošās komandas var atrast failā README.md mapē sa-webapp.

▍Konteinera attēla izveide Python lietojumprogrammai

Ja paskatās uz faila saturu Dockerfile mapē sa-logic, tad tur neko jaunu sev neatradīsi. Komandas attēla izveidei un nosūtīšanai uz krātuvi arī jums jau ir zināmas, taču, tāpat kā ar citām mūsu lietojumprogrammām, tās var atrast failā README.md mapē sa-logic.

▍ Konteineru lietojumprogrammu testēšana

Vai varat uzticēties kaut kam, ko neesat pārbaudījis? Es arī nevaru. Pārbaudīsim savus konteinerus.

Palaidīsim lietojumprogrammas konteineru sa-logic un konfigurējiet to, lai klausītos portā 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Palaidīsim lietojumprogrammas konteineru sa-webapp un konfigurējiet to, lai klausītos portā 8080. Turklāt mums ir jākonfigurē ports, kurā Python lietojumprogramma uzklausīs pieprasījumus no Java lietojumprogrammas, atkārtoti piešķirot vides mainīgo 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
```

Lai uzzinātu, kā uzzināt Docker konteinera vai virtuālās mašīnas IP adresi, skatiet failu README.

Palaidīsim lietojumprogrammas konteineru sa-frontend:

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

Tagad viss ir gatavs doties uz adresi pārlūkprogrammā localhost:80 un izmēģiniet lietojumprogrammu.

Lūdzu, ņemiet vērā, ka, ja mainījāt portu uz sa-webapp, vai, ja izmantojat Docker virtuālo mašīnu, fails būs jārediģē App.js no mapes sa-frontendmainot IP adresi vai porta numuru metodē analyzeSentence(), aizstājot pašreizējo informāciju novecojušo datu vietā. Pēc tam attēls ir jāsamontē un jāizmanto.

Tā tagad izskatās mūsu lietojumprogrammu diagramma.

Mikropakalpojumi darbojas konteineros

Kopsavilkums: kāpēc mums ir nepieciešams Kubernetes klasteris?

Mēs tikko izskatījām failus Dockerfile, runāja par to, kā izveidot attēlus un nosūtīt tos uz Docker repozitoriju. Turklāt mēs uzzinājām, kā paātrināt attēla montāžu, izmantojot failu .dockerignore. Rezultātā mūsu mikropakalpojumi tagad darbojas Docker konteineros. Šeit jums var rasties pilnīgi pamatots jautājums par to, kāpēc mums ir nepieciešams Kubernetes. Šī materiāla otrā daļa būs veltīta atbildei uz šo jautājumu. Tikmēr apsveriet šādu jautājumu:
Pieņemsim, ka mūsu tīmekļa lietojumprogramma teksta analīzei ir kļuvusi populāra visā pasaulē. Katru minūti viņam pienāk miljoniem pieprasījumu. Tas nozīmē, ka mikropakalpojumi sa-webapp и sa-logic tiks pakļauta milzīgai slodzei. Kā mērogot konteinerus, kuros darbojas mikropakalpojumi?

Avots: www.habr.com