Vadnica Kubernetes, 1. del: Aplikacije, mikrostoritve in vsebniki

Na našo željo je Habr ustvaril hub Kubernetes in z veseljem vanj umestimo prvo publikacijo. Naročite se!

Kubernetes je enostaven. Zakaj mi banke plačujejo veliko denarja za delo na tem področju, medtem ko lahko vsak obvlada to tehnologijo v le nekaj urah?

Če dvomite, da se Kubernetesa da naučiti tako hitro, vam predlagam, da to poskusite narediti sami. Ko boste namreč to gradivo osvojili, boste lahko v gruči Kubernetes poganjali aplikacijo, ki temelji na mikrostoritvah. To lahko zagotovim, ker po isti metodologiji, kot jo uporabljam tukaj, učim naše stranke, kako delati s Kubernetesom. V čem se ta vodnik razlikuje od drugih? Pravzaprav veliko stvari. Torej se večina teh materialov začne z razlago preprostih stvari - konceptov Kubernetesa in značilnosti ukaza kubectl. Avtorji teh člankov domnevajo, da njihov bralec pozna razvoj aplikacij, mikrostoritve in vsebnike Docker. Šli bomo v drugo smer. Najprej se pogovorimo o tem, kako v računalniku zagnati aplikacijo, ki temelji na mikrostoritvah. Nato si bomo ogledali gradnjo slik vsebnika za vsako mikrostoritev. Nato se bomo seznanili s Kubernetesom in analizirali postavitev aplikacije, ki temelji na mikrostoritvah v gruči, ki jo upravlja Kubernetes.

Ta pristop, s postopnim pristopom k Kubernetesu, bo dal globino razumevanja dogajanja, ki jo potrebuje povprečen človek, da bi razumel, kako preprosto je vse urejeno v Kubernetesu. Kubernetes je zagotovo preprosta tehnologija, pod pogojem, da kdor jo hoče obvladati, ve kje in kako se uporablja.

Zdaj pa se brez nadaljnjega odlašanja lotimo dela in se pogovorimo o aplikaciji, s katero bomo delali.

Eksperimentalna aplikacija

Naša aplikacija bo opravljala samo eno funkcijo. Kot vhod vzame en stavek, nato pa z orodji za analizo besedila izvede sentimentalno analizo tega stavka, s čimer pridobi oceno čustvenega odnosa avtorja stavka do določenega predmeta.

Tako je videti glavno okno te aplikacije.

Spletna aplikacija za analizo razpoloženja

S tehničnega vidika je aplikacija sestavljena iz treh mikrostoritev, od katerih vsaka rešuje določen nabor nalog:

• SA-Frontend je spletni strežnik Nginx, ki služi statičnim datotekam React.
• SA-WebApp je spletna aplikacija, napisana v Javi, ki obravnava zahteve iz sprednjega dela.
• SA-Logic je aplikacija Python, ki izvaja analizo razpoloženja besedila.

Pomembno je omeniti, da mikrostoritve ne obstajajo same po sebi. Uresničujejo idejo o "ločitvi dolžnosti", vendar morajo hkrati sodelovati drug z drugim.

Podatkovni tokovi v aplikaciji

V zgornjem diagramu lahko vidite oštevilčene stopnje sistema, ki ponazarjajo tokove podatkov v aplikaciji. Razčlenimo jih:

1. Brskalnik zahteva datoteko od strežnika index.html (kar nato naloži paket aplikacije React).
2. Uporabnik komunicira z aplikacijo, kar povzroči klic spletne aplikacije, ki temelji na Springu.
3. Spletna aplikacija posreduje zahtevo za razčlenitev besedila aplikaciji Python.
4. Aplikacija Python analizira občutek besedila in vrne rezultat kot odgovor na zahtevo.
5. Aplikacija Spring pošlje odgovor aplikaciji React (ta pa uporabniku prikaže rezultat razčlenjenega besedila).

Kodo za vse te aplikacije lahko najdete tukaj. Priporočam, da to skladišče takoj kopirate k sebi, saj je pred nami veliko zanimivih poskusov z njim.

Izvajanje aplikacije, ki temelji na mikrostoritvah na lokalnem računalniku

Da aplikacija deluje, moramo zagnati vse tri mikrostoritve. Začnimo z najlepšo med njimi – s sprednjo aplikacijo.

▍Nastavitev React za lokalni razvoj

Če želite zagnati aplikacijo React, morate v računalnik namestiti ogrodje Node.js in NPM. Ko vse to namestite, pojdite s terminalom v mapo projekta sa-frontend in zaženite naslednji ukaz:

npm install

Z izvajanjem tega ukaza v mapi node_modules naložile se bodo odvisnosti aplikacije React, katere zapisi so v datoteki package.json. Po prenosu odvisnosti v isto mapo zaženite naslednji ukaz:

npm start

To je vse. Aplikacija React se zdaj izvaja in do nje lahko dostopate tako, da se pomaknete na naslov brskalnika localhost:3000. Lahko spremenite nekaj v njegovi kodi. Učinek teh sprememb boste takoj videli v brskalniku. To je mogoče zaradi tako imenovane "vroče" zamenjave modulov. Zahvaljujoč temu se front-end razvoj spremeni v preprosto in prijetno izkušnjo.

▍Priprava aplikacije React za produkcijo

Za namene dejanske uporabe aplikacije React jo moramo pretvoriti v nabor statičnih datotek in jih ponuditi strankam, ki uporabljajo spletni strežnik.

Če želite zgraditi aplikacijo React, ponovno s pomočjo terminala se pomaknite do mape sa-frontend in zaženite naslednji ukaz:

npm run build

To bo ustvarilo imenik v mapi projekta build. Vsebovala bo vse statične datoteke, potrebne za delovanje aplikacije React.

▍Postrežba statičnih datotek z Nginxom

Najprej morate namestiti in zagnati spletni strežnik Nginx. Tukaj lahko ga prenesete in najdete navodila za namestitev in zagon. Nato morate kopirati vsebino mape sa-frontend/build v mapo [your_nginx_installation_dir]/html.

S tem pristopom se datoteka, ki nastane med sestavljanjem aplikacije React index.html bo na voljo na [your_nginx_installation_dir]/html/index.html. To je datoteka, ki jo privzeto izda strežnik Nginx, ko dostopa do nje. Strežnik je konfiguriran za poslušanje na vratih 80, vendar ga lahko prilagodite tako, kot želite, tako da uredite datoteko [your_nginx_installation_dir]/conf/nginx.conf.

Zdaj odprite brskalnik in pojdite na localhost:80. Videli boste stran aplikacije React.

Aplikacija React, ki jo streže strežnik Nginx

Če zdaj vnesete nekaj v polje Type your sentence in pritisnite gumb Send - nič se ne bo zgodilo. Toda če pogledate konzolo, lahko tam vidite sporočila o napakah. Da bi natančno razumeli, kje se te napake pojavljajo, analizirajmo kodo aplikacije.

▍Analiza kode front-end aplikacije

Gledam kodo datoteke App.js, lahko to vidimo s klikom na gumb Send pokliče metodo analyzeSentence(). Koda za to metodo je prikazana spodaj. Hkrati bodite pozorni na dejstvo, da za vsako vrstico, na katero je priložen komentar obrazca # Номер, pod kodo je podana razlaga. Na enak način bomo razčlenili druge fragmente kode.

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, na katerega je poslana zahteva POST. Predpostavlja se, da je ta naslov aplikacija, ki čaka na takšne zahteve.

2.Telo zahteve, poslano aplikaciji. Tukaj je primer telesa zahteve:

{
    sentence: "I like yogobella!"
}

3.Ko prejmete odgovor na zahtevo, se stanje komponente posodobi. To povzroči ponovno upodobitev komponente. Če prejmemo podatke (tj. objekt JSON, ki vsebuje vnesene podatke in izračunano oceno besedila), bomo izpisali komponento Polaritydokler so izpolnjeni pogoji. Tukaj opisujemo komponento:

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

Zdi se, da koda deluje precej dobro. Kaj je tukaj sploh narobe? Če predvidevate, da na naslovu, na katerega aplikacija poskuša poslati POST zahtevo, še ni ničesar, kar bi to zahtevo lahko sprejelo in obdelalo, potem boste imeli popolnoma prav. In sicer za obdelavo zahtevkov, ki prihajajo na naslov http://localhost:8080/sentiment, moramo zagnati spletno aplikacijo, ki temelji na Springu.

Potrebujemo aplikacijo Spring, ki lahko sprejme zahtevo POST

▍Nastavitev spletne aplikacije, ki temelji na Springu

Če želite razmestiti aplikacijo Spring, potrebujete JDK8 in Maven ter pravilno konfigurirane spremenljivke okolja. Ko vse to namestite, lahko nadaljujete z delom na našem projektu.

▍Pakiranje aplikacije v datoteko jar

S terminalom se pomaknite do mape sa-webapp in vnesite naslednji ukaz:

mvn install

Po izvedbi tega ukaza v mapi sa-webapp imenik bo ustvarjen target. Tukaj se nahaja aplikacija Java, zapakirana v datoteko jar, ki jo predstavlja datoteka sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Zagon aplikacije Java

Pojdite v mapo target in zaženite aplikacijo z naslednjim ukazom:

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

Med izvajanjem tega ukaza bo prišlo do napake. Da bi začeli popravljati, lahko razčlenimo podrobnosti izjeme v podatkih sledenja sklada:

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

Za nas je tu najpomembnejša omemba nezmožnosti razjasnitve pomena sa.logic.api.url. Analizirajmo kodo, kjer se pojavi napaka.

▍Analiza kode aplikacije Java

Tukaj je delček kode, kjer se pojavi napaka.

@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. V SentimentController tam je polje saLogicApiUrl. Njegova vrednost je določena z lastnostjo sa.logic.api.url.
2. Linija saLogicApiUrl povezuje z vrednostjo /analyse/sentiment. Skupaj tvorijo naslov za klicanje mikrostoritve, ki izvaja analizo besedila.

▍Nastavitev vrednosti lastnosti

V Spring je privzeti vir vrednosti lastnosti datoteka application.properties, ki ga najdete na sa-webapp/src/main/resources. Vendar njegova uporaba ni edini način za nastavitev vrednosti lastnosti. To lahko storite tudi z naslednjim ukazom:

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

Vrednost te lastnosti mora kazati na naslov naše aplikacije Python.

Če jo konfiguriramo, sporočimo spletni aplikaciji Spring, kam mora iti, da naredi zahteve za razčlenjevanje besedila.

Da si ne bomo komplicirali življenja, se bomo odločili, da bo aplikacija Python na voljo na localhost:5000 in poskusite ne pozabiti na to. Posledično bo ukaz za zagon aplikacije Spring videti takole:

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

V našem sistemu manjka aplikacija Python

Zdaj moramo le še zagnati aplikacijo Python in sistem bo deloval po pričakovanjih.

▍Nastavitev aplikacije Python

Če želite zagnati aplikacijo Python, morate imeti nameščena Python 3 in Pip ter imeti pravilno nastavljene ustrezne spremenljivke okolja.

▍Namestitev odvisnosti

Pojdite v mapo projekta sa-logic/sa in zaženite naslednje ukaze:

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

▍Zagon aplikacije

Z nameščenimi odvisnostmi smo pripravljeni za zagon aplikacije:

python sentiment_analysis.py

Po izvedbi tega ukaza nam bo povedano naslednje:

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

To pomeni, da aplikacija teče in čaka na zahteve pri localhost:5000/

▍Raziskava kode

Oglejmo si kodo aplikacije Python, da bi razumeli, kako se odziva na zahteve:

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. Inicializacija objekta Flask.
2. Določanje naslova za pošiljanje zahtev POST nanj.
3. Pridobivanje nepremičnine sentence iz telesa zahteve.
4. Inicializacija anonimnega objekta TextBlob in pridobivanje vrednosti polarity za prvi prejeti predlog v telesu zahteve (v našem primeru je to edini predlog, oddan v analizo).
5. Vrnitev odgovora, katerega telo vsebuje besedilo ponudbe in zanjo izračunan indikator polarity.
6. Zagon aplikacije Flask, ki bo na voljo na 0.0.0.0:5000 (do njega lahko dostopate tudi s konstrukcijo obrazca localhost:5000).

Zdaj se izvajajo mikrostoritve, ki sestavljajo aplikacijo. Nastavljeni so za interakcijo drug z drugim. Tukaj je videti diagram aplikacije na tej stopnji dela.

Vse mikrostoritve, ki sestavljajo aplikacijo, so spravljene v zdravo stanje

Zdaj, preden nadaljujemo, odprite aplikacijo React v brskalniku in poskusite z njo razčleniti kakšen stavek. Če je vse opravljeno pravilno - po pritisku na gumb Send pod besedilnim poljem boste videli rezultate analize.

V naslednjem razdelku bomo govorili o tem, kako zagnati naše mikrostoritve v vsebnikih Docker. To je potrebno za pripravo aplikacije za izvajanje v gruči Kubernetes.

Docker kontejnerji

Kubernetes je sistem za avtomatizacijo uvajanja, skaliranja in upravljanja kontejnerskih aplikacij. Imenuje se tudi "kontejnerski orkestrator". Če Kubernetes deluje s kontejnerji, moramo pred uporabo tega sistema najprej pridobiti te kontejnerje. Toda najprej se pogovorimo o tem, kaj so zabojniki. Morda najboljši odgovor na vprašanje, kaj je to, lahko najdete v dokumentacijo za Docker:

Slika vsebnika je lahek, samostojen, izvršljiv paket, ki vsebuje aplikacijo, ki vključuje vse, kar je potrebno za njeno izvajanje: kodo aplikacije, izvajalno okolje, sistemska orodja in knjižnice, nastavitve. Kontejnerske programe je mogoče uporabljati v okoljih Linux in Windows in bodo vedno delovali enako, ne glede na infrastrukturo.

To pomeni, da lahko vsebnike izvajate na katerem koli računalniku, vključno s produkcijskimi strežniki, in v katerem koli okolju bodo aplikacije, ki jih vsebujejo, delovale na enak način.

Da bi raziskali funkcije vsebnikov in jih primerjali z drugimi načini izvajanja aplikacij, si oglejmo primer streženja aplikacije React z uporabo virtualnega stroja in vsebnika.

▍Postrežba statičnih datotek aplikacije React z uporabo virtualnega stroja

Če poskušamo organizirati vzdrževanje statičnih datotek z uporabo virtualnih strojev, bomo naleteli na naslednje pomanjkljivosti:

1. Neučinkovita uporaba virov, saj je vsak virtualni stroj popoln operacijski sistem.
2. Odvisnost od platforme. Kar deluje na lokalnem računalniku, morda ne bo delovalo na produkcijskem strežniku.
3. Počasno in z viri intenzivno skaliranje rešitve virtualnega stroja.

Spletni strežnik Nginx, ki streže statične datoteke, ki se izvajajo v virtualnem računalniku

Če se kontejnerji uporabljajo za reševanje podobnega problema, potem lahko v primerjavi z virtualnimi stroji opazimo naslednje prednosti:

1. Učinkovita uporaba virov: delo z operacijskim sistemom s pomočjo Dockerja.
2. Neodvisnost platforme. Vsebnik, ki ga razvijalec lahko izvaja na svojem računalniku, bo deloval kjer koli.
3. Lahka uvedba z uporabo slikovnih plasti.

Spletni strežnik Nginx, ki streže statične datoteke, ki se izvajajo v vsebniku

Virtualne stroje in vsebnike smo primerjali le v nekaj točkah, vendar je tudi to dovolj, da dobimo občutek o prednostih vsebnikov. Tukaj Najdete lahko podrobnosti o vsebnikih Docker.

▍Gradnja slike vsebnika za aplikacijo React

Osnovni gradnik vsebnika Docker je datoteka Dockerfile. Na začetku te datoteke je posneta osnovna slika vsebnika, nato pa je vključeno zaporedje navodil, ki kažejo, kako ustvariti vsebnik, ki bo ustrezal potrebam aplikacije.

Preden začnemo delati z datoteko Dockerfile, spomnite se, kaj smo storili, da smo pripravili datoteke aplikacije React za nalaganje na strežnik Nginx:

1. Izdelava paketa aplikacije React (npm run build).
2. Zagon strežnika Nginx.
3. Kopiranje vsebine imenika build iz mape projekta sa-frontend v mapo strežnika nginx/html.

Spodaj lahko vidite vzporednice med ustvarjanjem vsebnika in zgornjimi dejanji, izvedenimi v lokalnem računalniku.

▍Priprava datoteke Docker za aplikacijo SA-Frontend

Navodila, ki jih je treba vključiti v Dockerfile za uporabo SA-Frontend, sestavljen iz samo dveh ukazov. Dejstvo je, da je razvojna ekipa Nginx pripravila osnovno sliko za Nginx, ki ga bomo uporabili za gradnjo naše podobe. Tukaj sta dva koraka, ki ju moramo opisati:

1. Za osnovo slike morate narediti sliko Nginx.
2. Vsebina mape sa-frontend/build morate kopirati v slikovno mapo nginx/html.

Če gremo od tega opisa do datoteke Dockerfile, potem bo videti takole:

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

Kot lahko vidite, je tukaj vse zelo preprosto, medtem ko se vsebina datoteke celo izkaže za precej berljivo in razumljivo. Ta datoteka sporoči sistemu, naj posname sliko nginx z vsem, kar že ima, in kopirajte vsebino imenika build v imenik nginx/html.

Tu boste morda imeli vprašanje, kako vem, kam natančno kopirati datoteke iz mape build, torej od kod pot /usr/share/nginx/html. Pravzaprav tudi tukaj ni nič zapletenega. Dejstvo je, da je ustrezne informacije mogoče najti v opis slike.

▍Sestavljanje slike in njeno nalaganje v repozitorij

Preden lahko delamo z dokončano sliko, jo moramo poslati v repozitorij slik. Za to bomo uporabili brezplačno platformo za gostovanje slik v oblaku Docker Hub. Na tej stopnji dela morate narediti naslednje:

1. Namestite Lučki delavec.
2. Registrirajte se na spletnem mestu Docker Hub.
3. Prijavite se v svoj račun tako, da v terminalu zaženete naslednji ukaz:

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

Zdaj morate s terminalom iti v imenik sa-frontend in tam zaženite naslednji ukaz:

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

Tukaj in spodaj v podobnih ukazih $DOCKER_USER_ID zamenjati z vašim uporabniškim imenom v Docker Hubu. Na primer, ta del ukaza je lahko videti takole: rinormaloku/sentiment-analysis-frontend.

V tem primeru lahko ta ukaz skrajšate tako, da iz njega odstranite -f Dockerfile, saj mapa, v kateri izvajamo ta ukaz, že vsebuje to datoteko.

Za pošiljanje končane slike v repozitorij potrebujemo naslednji ukaz:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Ko ga dokončate, preverite svoj seznam repozitorijev v Docker Hubu, da vidite, ali je bila slika uspešno potisnjena v shrambo v oblaku.

▍Zagon vsebnika

Zdaj lahko vsak prenese in zažene sliko, znano kot $DOCKER_USER_ID/sentiment-analysis-frontend. Če želite to narediti, morate zagnati naslednje zaporedje ukazov:

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

Zdaj se vsebnik izvaja in lahko nadaljujemo z delom z ustvarjanjem drugih slik, ki jih potrebujemo. Toda preden nadaljujemo, poglejmo zasnovo 80:80, ki se nahaja v ukazu za zagon slike in se morda zdi zmeden.

• Prva številka 80 je številka vrat gostitelja (to je lokalnega računalnika).
• Druga številka 80 je vrata vsebnika, kamor naj bo zahteva preusmerjena.

Razmislite o naslednji ilustraciji.

Posredovanje vrat

Sistem posreduje zahteve iz vrat <hostPort> v pristanišče <containerPort>. Se pravi dostop do pristanišča 80 računalnik je preusmerjen na vrata 80 posoda.

Od pristanišča 80 odprt v lokalnem računalniku, lahko dostopate do aplikacije iz tega računalnika na localhost:80. Če vaš sistem ne podpira Dockerja, lahko aplikacijo zaženete na virtualnem računalniku Docker, katerega naslov bo videti kot <docker-machine ip>:80. Če želite izvedeti naslov IP virtualnega stroja Docker, lahko uporabite ukaz docker-machine ip.

Na tej točki, ko se vsebnik čelne aplikacije uspešno zažene, bi morali imeti možnost odpreti njegovo stran v brskalniku.

▍.dockerignore datoteka

Gradnja podobe aplikacije SA-Frontend, lahko opazimo, da je ta proces izjemno počasen. To je zato, ker je treba kontekst gradnje slike poslati demonu Docker. Imenik, ki predstavlja kontekst gradnje, je podan kot zadnji argument ukaza docker build. V našem primeru je na koncu tega ukaza pika. Posledica tega je, da je naslednja struktura vključena v kontekst sestavljanja:

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

Toda od vseh tukaj prisotnih map potrebujemo samo mapo build. Prenašanje česar koli drugega je izguba časa. Gradnjo lahko pospešite tako, da Dockerju poveste, katere imenike naj prezre. Da bi to naredili, potrebujemo datoteko .dockerignore. Vi, če ste seznanjeni z datoteko .gitignore, bo struktura te datoteke verjetno videti znana. Navaja imenike, ki jih sistem za gradnjo slike lahko prezre. V našem primeru je vsebina te datoteke videti takole:

node_modules
src
public

datoteka .dockerignore mora biti v isti mapi kot datoteka Dockerfile. Zdaj bo sestavljanje slike trajalo nekaj sekund.

Opravimo zdaj sliko za aplikacijo Java.

▍Gradnja slike vsebnika za aplikacijo Java

Veste kaj in naučili ste se že vsega, kar potrebujete za ustvarjanje slik vsebnikov. Zato bo ta del zelo kratek.

Odprite datoteko Dockerfile, ki se nahaja v mapi projekta sa-webapp. Če preberete besedilo te datoteke, boste v njej srečali le dve novi konstrukciji, ki se začneta s ključnimi besedami ENV и EXPOSE:

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

Ključna beseda ENV vam omogoča, da deklarirate spremenljivke okolja znotraj vsebnikov Docker. Zlasti v našem primeru omogoča nastavitev URL-ja za dostop do API-ja aplikacije, ki izvaja analizo besedila.

Ključna beseda EXPOSE vam omogoča, da Dockerju naročite, naj odpre vrata. Ta vrata bomo uporabljali pri delu z aplikacijo. Tukaj lahko to vidite v Dockerfile za uporabo SA-Frontend takega ukaza ni. To je samo za namene dokumentacije, z drugimi besedami, ta konstrukcija je za bralca Dockerfile.

Sestavljanje slike in njeno potiskanje v repozitorij izgleda natanko tako kot prejšnji primer. Če še niste zelo prepričani v svoje sposobnosti, lahko ustrezne ukaze najdete v datoteki README.md v mapi sa-webapp.

▍Gradnja slike vsebnika za aplikacijo Python

Če pogledate vsebino datoteke Dockerfile v mapi sa-logictam ne boste našli nič novega. Ukaze za gradnjo slike in njeno potiskanje v repozitorij bi morali prav tako poznati, vendar jih, kot velja za druge naše aplikacije, najdete v datoteki README.md v mapi sa-logic.

▍Testiranje kontejnerskih aplikacij

Ali lahko zaupate nečemu, česar niste preizkusili? Tudi jaz ne morem. Preizkusimo naše posode.

1. Zaženimo vsebnik aplikacij sa-logic in ga konfigurirajte za poslušanje na vratih 5050:

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

2. Zaženimo vsebnik aplikacij sa-webapp in ga konfigurirajte za poslušanje na vratih 8080. Poleg tega moramo nastaviti vrata, na katerih bo aplikacija Python poslušala zahteve aplikacije Java s prerazporeditvijo spremenljivke okolja 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

Če želite izvedeti, kako najti naslov IP vsebnika ali Docker VM, glejte datoteko README.

Zaženimo vsebnik aplikacij sa-frontend:

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

Zdaj je vse pripravljeno za navigacijo v brskalniku do naslova localhost:80 in preizkusite aplikacijo.

Upoštevajte, da če spremenite vrata za sa-webapp, ali če uporabljate Docker VM, boste morali urediti datoteko App.js iz mape sa-frontends spremembo naslova IP ali številke vrat v metodi analyzeSentence()z zamenjavo trenutnih informacij namesto zastarelih podatkov. Po tem morate ponovno sestaviti sliko in jo uporabiti.

Tako je zdaj videti naš diagram aplikacije.

Mikrostoritve delujejo v vsebnikih

Povzetek: zakaj potrebujemo gručo Kubernetes?

Pravkar smo pregledali datoteke Dockerfile, je govoril o tem, kako zgraditi slike in jih potisniti v repozitorij Docker. Poleg tega smo se naučili, kako s pomočjo datoteke pospešiti sestavljanje slik .dockerignore. Posledično se naše mikrostoritve zdaj izvajajo v vsebnikih Docker. Tu se lahko pojavi povsem upravičeno vprašanje, zakaj potrebujemo Kubernetes. Odgovor na to vprašanje bo posvečen drugemu delu tega gradiva. Medtem razmislite o naslednjem vprašanju:
Predpostavimo, da je naša spletna aplikacija za analizo besedil postala priljubljena po vsem svetu. Vsako minuto mu pride na milijone prošenj. To pomeni, da mikrostoritve sa-webapp и sa-logic bo pod velikim stresom. Kako povečati vsebnike, ki izvajajo mikrostoritve?

Vir: www.habr.com