Výukový program Kubernetes, časť 1: Aplikácie, mikroslužby a kontajnery

Na našu žiadosť Habr vytvoril hub Kubernetes a sme radi, že do nej umiestnime prvú publikáciu. Prihláste sa na odber!

Kubernetes je jednoduchý. Prečo mi banky platia veľa peňazí za prácu v tejto oblasti, pričom túto technológiu zvládne každý za pár hodín?

Ak pochybujete, že Kubernetes sa dá naučiť tak rýchlo, odporúčam vám, aby ste si to vyskúšali sami. Po zvládnutí tohto materiálu budete môcť spustiť aplikáciu založenú na mikroslužbách v klastri Kubernetes. Môžem to zaručiť, pretože je to presne tá istá metodika, ktorá sa tu používa, ako učím našich klientov pracovať s Kubernetes. Čím sa táto príručka líši od ostatných? V skutočnosti je toho veľa. Väčšina týchto materiálov teda začína vysvetlením jednoduchých vecí - konceptov Kubernetes a funkcií príkazu kubectl. Autori týchto materiálov predpokladajú, že ich čitatelia poznajú vývoj aplikácií, mikroslužby a kontajnery Docker. Pôjdeme inou cestou. Najprv si povieme, ako spustiť aplikáciu založenú na mikroslužbách na počítači. Potom sa pozrieme na vytváranie obrázkov kontajnerov pre každú mikroslužbu. A potom sa zoznámime s Kubernetes a pozrieme sa na nasadenie aplikácie založenej na mikroslužbách v klastri spravovanom Kubernetes.

Tento prístup s postupným prístupom ku Kubernetes poskytne hĺbku pochopenia toho, čo sa deje, čo je pre priemerného človeka potrebné, aby pochopil, ako jednoducho všetko v Kubernetes funguje. Kubernetes je určite jednoduchá technológia za predpokladu, že tí, ktorí sa ju chcú naučiť, vedia, kde a ako sa používa.

Teraz bez ďalších okolkov začnime a porozprávajme sa o aplikácii, s ktorou budeme pracovať.

Experimentálna aplikácia

Naša aplikácia bude vykonávať iba jednu funkciu. Ako vstup berie jednu vetu, po ktorej pomocou nástrojov na analýzu textu vykoná sentimentálnu analýzu tejto vety, čím získa hodnotenie emocionálneho postoja autora vety k určitému objektu.

Takto vyzerá hlavné okno tejto aplikácie.

Webová aplikácia na analýzu sentimentu textov

Z technického hľadiska sa aplikácia skladá z troch mikroslužieb, z ktorých každá rieši špecifický súbor problémov:

• SA-Frontend je webový server Nginx, ktorý obsluhuje statické súbory React.
• SA-WebApp je webová aplikácia napísaná v jazyku Java, ktorá spracováva požiadavky z frontendu.
• SA-Logic je aplikácia Python, ktorá vykonáva analýzu sentimentu v texte.

Je dôležité poznamenať, že mikroslužby neexistujú samostatne. Realizujú myšlienku „oddelenia povinností“, ale zároveň musia navzájom spolupracovať.

Dátové toky v aplikácii

Vo vyššie uvedenom diagrame môžete vidieť očíslované stupne systému, ktoré ilustrujú dátové toky v aplikácii. Pozrime sa na ne:

1. Prehliadač požaduje súbor zo servera index.html (ktorý zase stiahne balík aplikácie React).
2. Používateľ interaguje s aplikáciou, čo spôsobí volanie webovej aplikácie založenej na Spring.
3. Webová aplikácia prepošle požiadavku na vykonanie analýzy textu do aplikácie Python.
4. Aplikácia Python vykoná analýzu sentimentu textu a vráti výsledok ako odpoveď na požiadavku.
5. Aplikácia Spring odošle odpoveď aplikácii React (ktorá zase zobrazí výsledok analýzy textu používateľovi).

Kód pre všetky tieto aplikácie nájdete tu. Odporúčam vám, aby ste si toto úložisko skopírovali pre seba hneď teraz, pretože je pred nami veľa zaujímavých experimentov s ním.

Spustenie aplikácie založenej na mikroslužbách na vašom lokálnom počítači

Aby aplikácia fungovala, musíme spustiť všetky tri mikroslužby. Začnime tým najroztomilejším zo všetkých – front-end aplikáciou.

▍Nastavte React pre miestny rozvoj

Ak chcete spustiť aplikáciu React, musíte si do počítača nainštalovať platformu Node.js a NPM. Keď máte toto všetko nainštalované, prejdite pomocou terminálu do priečinka projektu sa-frontend a spustite nasledujúci príkaz:

npm install

Spustením tohto príkazu v priečinku node_modules načítajú sa závislosti aplikácie React, ktorých záznamy sú v súbore package.json. Po stiahnutí závislostí do rovnakého priečinka spustite nasledujúci príkaz:

npm start

To je všetko. Teraz je aplikácia React spustená, môžete k nej pristupovať tak, že vo svojom prehliadači prejdete na nasledujúcu adresu: localhost:3000. V jeho kóde môžete niečo zmeniť. Efekt týchto zmien okamžite uvidíte v prehliadači. Je to možné vďaka takzvanej „horúcej“ výmene modulov. Vďaka tomu je vývoj front-endu jednoduchý a príjemný.

▍Príprava aplikácie React na produkciu

Aby sme mohli skutočne používať aplikáciu React, musíme ju previesť na sadu statických súborov a poskytnúť ich klientom pomocou webového servera.

Ak chcete zostaviť aplikáciu React, znova pomocou terminálu prejdite do priečinka sa-frontend a spustite nasledujúci príkaz:

npm run build

Tým sa vytvorí adresár v priečinku projektu build. Bude obsahovať všetky statické súbory potrebné na fungovanie aplikácie React.

▍Poskytovanie statických súborov pomocou Nginx

Najprv musíte nainštalovať a spustiť webový server Nginx. Tu môžete si ho stiahnuť a nájsť pokyny, ako ho nainštalovať a spustiť. Potom musíte skopírovať obsah priečinka sa-frontend/build do priečinka [your_nginx_installation_dir]/html.

S týmto prístupom sa súbor vygeneruje počas procesu zostavovania aplikácie React index.html bude k dispozícii na [your_nginx_installation_dir]/html/index.html. Toto je súbor, ktorý štandardne vytvára server Nginx pri prístupe k nemu. Server je nakonfigurovaný na počúvanie na porte 80, ale dá sa upraviť tak, ako potrebujete, úpravou súboru [your_nginx_installation_dir]/conf/nginx.conf.

Teraz otvorte prehliadač a prejdite na localhost:80. Uvidíte stránku aplikácie React.

Reagovať aplikáciu obsluhovanú serverom Nginx

Ak teraz niečo zadáte do poľa Type your sentence a stlačte tlačidlo Send - nič sa nestane. Ak sa však pozriete na konzolu, môžete tam vidieť chybové hlásenia. Aby sme pochopili, kde presne sa tieto chyby vyskytujú, analyzujme kód aplikácie.

▍ Analýza kódu prednej aplikácie

Pozrite sa na kód súboru App.js, môžeme vidieť, že stlačením tlačidla Send volá metódu analyzeSentence(). Kód tejto metódy je uvedený nižšie. Upozorňujeme, že pre každý riadok, ktorý má komentár formulára # Номер, pod kódom je uvedené vysvetlenie. Rovnakým spôsobom analyzujeme ďalšie fragmenty kódu.

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. Adresa URL, na ktorú sa odošle požiadavka POST. Predpokladá sa, že na tejto adrese je aplikácia, ktorá takéto požiadavky očakáva.

2.Žiadosť odoslaná do aplikácie. Tu je príklad tela žiadosti:

{
    sentence: "I like yogobella!"
}

3.Po prijatí odpovede na požiadavku sa aktualizuje stav komponentu. To spôsobí opätovné vykreslenie komponentu. Ak prijmeme údaje (t. j. objekt JSON obsahujúci vstupné údaje a vypočítané textové skóre), vydáme komponent Polarity, keďže budú splnené príslušné podmienky. Takto popisujeme komponent:

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

Zdá sa, že kód funguje celkom dobre. Čo je na tom zlé? Ak predpokladáte, že na adrese, na ktorú sa aplikácia pokúša poslať POST požiadavku, zatiaľ nie je nič, čo by túto požiadavku mohlo prijať a spracovať, tak budete mať úplnú pravdu. Totiž na spracovanie žiadostí prijatých o http://localhost:8080/sentiment, musíme spustiť webovú aplikáciu založenú na Spring.

Potrebujeme aplikáciu Spring, ktorá dokáže prijať požiadavku POST

▍Nastavenie webovej aplikácie založenej na jar

Na nasadenie aplikácie Spring budete potrebovať JDK8 a Maven a správne nakonfigurované premenné prostredia. Keď máte toto všetko nainštalované, môžete pokračovať v práci na našom projekte.

▍Zabalenie aplikácie do súboru jar

Pomocou terminálu prejdite do priečinka sa-webapp a zadajte nasledujúci príkaz:

mvn install

Po spustení tohto príkazu v priečinku sa-webapp vytvorí sa adresár target. Tu sa bude nachádzať Java aplikácia zabalená v súbore jar, ktorý predstavuje súbor sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Spustenie aplikácie Java

Prejdite do priečinka target a spustite aplikáciu s nasledujúcim príkazom:

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

Pri vykonávaní tohto príkazu sa vyskytne chyba. Aby sme to mohli začať opravovať, môžeme analyzovať podrobnosti o výnimkách v údajoch sledovania zásobníka:

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

Pre nás je tu najdôležitejšia zmienka o nemožnosti objasnenia významu sa.logic.api.url. Poďme analyzovať kód, v ktorom sa chyba vyskytuje.

▍Analýza kódu aplikácie Java

Tu je útržok kódu, kde sa chyba vyskytuje.

@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 je tam pole saLogicApiUrl. Jeho hodnotu určuje vlastnosť sa.logic.api.url.
2. Riadok saLogicApiUrl sa spája s hodnotou /analyse/sentiment. Spoločne tvoria adresu pre uskutočnenie hovoru do mikroslužby, ktorá vykonáva analýzu textu.

▍Nastavte hodnotu vlastnosti

Na jar je štandardným zdrojom hodnôt vlastností súbor application.properties, ktorý nájdete na sa-webapp/src/main/resources. Ale jeho použitie nie je jediný spôsob, ako nastaviť hodnoty vlastností. Môžete to urobiť aj pomocou nasledujúceho príkazu:

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

Hodnota tejto vlastnosti by mala ukazovať na adresu našej aplikácie Python.

Jeho konfiguráciou povieme webovej aplikácii Spring, kam má ísť, aby vykonala požiadavky na analýzu textu.

Aby sme si nekomplikovali život, rozhodneme sa, že aplikácia Python bude dostupná na localhost:5000 a snažme sa na to nezabudnúť. V dôsledku toho bude príkaz na spustenie aplikácie Spring vyzerať takto:

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

V našom systéme chýba aplikácia Python

Teraz už len stačí spustiť aplikáciu Python a systém bude fungovať podľa očakávania.

▍Nastavenie aplikácie Python

Ak chcete spustiť aplikáciu Python, musíte mať nainštalované Python 3 a Pip a musia byť správne nastavené príslušné premenné prostredia.

▍Inštalácia závislostí

Prejdite do priečinka projektu sa-logic/sa a spustite nasledujúce príkazy:

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

▍Spustite aplikáciu

Po nainštalovaní závislostí sme pripravení spustiť aplikáciu:

python sentiment_analysis.py

Po spustení tohto príkazu nám bude povedané nasledovné:

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

To znamená, že aplikácia je spustená a čaká na požiadavky na localhost:5000/

▍Výskum kódu

Pozrime sa na kód aplikácie Python, aby sme pochopili, ako reaguje na požiadavky:

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. Inicializácia objektu Flask.
2. Zadanie adresy na vykonávanie požiadaviek POST na ňu.
3. Získavanie nehnuteľnosti sentence od orgánu žiadosti.
4. Inicializácia anonymného objektu TextBlob a získanie hodnoty polarity za prvú vetu prijatú v tele žiadosti (v našom prípade je to jediná veta odoslaná na analýzu).
5. Vrátenie odpovede, ktorej telo obsahuje text vety a pre ňu vypočítaný ukazovateľ polarity.
6. Spustite aplikáciu Flask, ktorá bude dostupná na 0.0.0.0:5000 (dostanete sa k nemu aj pomocou konštrukcie formulára localhost:5000).

Mikroslužby, ktoré tvoria aplikáciu, sú teraz spustené. Sú naladení na vzájomnú interakciu. Takto vyzerá aplikačný diagram v tejto fáze práce.

Všetky mikroslužby, ktoré tvoria aplikáciu, sú uvedené do prevádzkyschopného stavu

Teraz, skôr ako budete pokračovať, otvorte aplikáciu React v prehliadači a skúste pomocou nej analyzovať nejakú vetu. Ak je všetko vykonané správne - po stlačení tlačidla Send výsledky analýzy uvidíte pod textovým poľom.

V ďalšej časti si povieme, ako spustiť naše mikroslužby v kontajneroch Docker. Je to potrebné na prípravu aplikácie na spustenie v klastri Kubernetes.

Docker kontajnery

Kubernetes je systém na automatizáciu nasadenia, škálovania a správy kontajnerových aplikácií. Nazýva sa aj „kontajnerový orchestrátor“. Ak Kubernetes pracuje s kontajnermi, potom pred použitím tohto systému musíme tieto kontajnery najskôr získať. Najprv si však povedzme, čo sú kontajnery. Azda najlepšiu odpoveď na otázku, čo to je, nájdete v dokumentáciu do Dockera:

Obraz kontajnera je ľahký, samostatný spustiteľný balík obsahujúci aplikáciu, ktorá obsahuje všetko potrebné na jej spustenie: kód aplikácie, prostredie na spustenie, systémové nástroje a knižnice, nastavenia. Kontajnerové programy je možné používať v prostrediach Linux a Windows a budú vždy fungovať rovnako bez ohľadu na infraštruktúru.

To znamená, že kontajnery môžu byť spustené na akomkoľvek počítači, vrátane produkčných serverov, a aplikácie v nich obsiahnuté budú fungovať rovnako v akomkoľvek prostredí.

Ak chcete preskúmať funkcie kontajnerov a porovnať ich s inými spôsobmi spúšťania aplikácií, pozrime sa na príklad obsluhy aplikácie React pomocou virtuálneho počítača a kontajnera.

▍Poskytovanie statických súborov aplikácie React pomocou virtuálneho počítača

Pri pokuse o organizáciu služby statických súborov pomocou virtuálnych strojov narazíme na nasledujúce nevýhody:

1. Neefektívne využívanie zdrojov, keďže každý virtuálny stroj je plnohodnotný operačný systém.
2. Závislosť na platforme. To, čo funguje na lokálnom počítači, nemusí fungovať na produkčnom serveri.
3. Pomalé a na zdroje náročné škálovanie riešenia založeného na virtuálnom stroji.

Webový server Nginx obsluhujúci statické súbory bežiace na virtuálnom počítači

Ak sa na vyriešenie podobného problému používajú kontajnery, potom v porovnaní s virtuálnymi strojmi možno zaznamenať tieto silné stránky:

1. Efektívne využívanie zdrojov: práca s operačným systémom pomocou Docker.
2. Nezávislé na platforme. Kontajner, ktorý môže vývojár spustiť na svojom počítači, bude fungovať kdekoľvek.
3. Ľahké nasadenie vďaka použitiu obrazových vrstiev.

Webový server Nginx obsluhujúci statické súbory bežiace v kontajneri

Virtuálne stroje a kontajnery sme porovnávali len v niekoľkých bodoch, ale aj to stačí na to, aby sme si uvedomili silné stránky kontajnerov. Tu Podrobnosti o kontajneroch Docker nájdete.

▍Vytvorenie obrazu kontajnera pre aplikáciu React

Základným stavebným kameňom kontajnera Docker je súbor Dockerfile. Na začiatku tohto súboru sa vytvorí záznam o základnom obrázku kontajnera, potom nasleduje postupnosť pokynov, ako vytvoriť kontajner, ktorý bude spĺňať potreby určitej aplikácie.

Skôr ako začneme pracovať so súborom Dockerfile, pripomeňme si, čo sme urobili, aby sme pripravili súbory aplikácie React na nahranie na server Nginx:

1. Vytvorenie balíka aplikácií React (npm run build).
2. Spustenie servera Nginx.
3. Kopírovanie obsahu adresára build z priečinka projektu sa-frontend do priečinka servera nginx/html.

Nižšie môžete vidieť paralely medzi vytvorením kontajnera a vyššie uvedenými krokmi vykonanými na vašom lokálnom počítači.

▍Príprava Dockerfile pre aplikáciu SA-Frontend

Pokyny, ktoré budú obsiahnuté v Dockerfile na aplikáciu SA-Frontend, pozostávajú iba z dvoch tímov. Faktom je, že vývojársky tím Nginx pripravil zákl obraz pre Nginx, ktorý použijeme na vytvorenie nášho obrazu. Toto sú dva kroky, ktoré musíme opísať:

1. Základom obrázku by mal byť obrázok Nginx.
2. Obsah priečinka sa-frontend/build je potrebné skopírovať do priečinka s obrázkami nginx/html.

Ak prejdete z tohto popisu do súboru Dockerfile, potom to bude vyzerať takto:

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

Ako vidíte, všetko je tu veľmi jednoduché a obsah súboru je dokonca celkom čitateľný a zrozumiteľný. Tento súbor hovorí systému, aby urobil obrázok nginx so všetkým, čo sa v ňom už nachádza, a skopírujte obsah adresára build do adresára nginx/html.

Tu môžete mať otázku, ako viem, kde presne potrebujete skopírovať súbory z priečinka build, teda odkiaľ prišla cesta /usr/share/nginx/html. V skutočnosti ani tu nie je nič zložité. Faktom je, že relevantné informácie možno nájsť v popis obrázok.

▍Vytvorenie obrázka a jeho nahranie do úložiska

Predtým, ako budeme môcť pracovať s hotovým obrázkom, musíme ho vložiť do úložiska obrázkov. Na tento účel použijeme bezplatnú platformu na hosťovanie obrázkov v cloude Docker Hub. V tejto fáze práce musíte urobiť nasledovné:

1. zriadiť prístavný robotník.
2. Zaregistrujte sa na webovej stránke Docker Hub.
3. Prihláste sa do svojho účtu spustením nasledujúceho príkazu v termináli:

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

Teraz musíte pomocou terminálu prejsť do adresára sa-frontend a tam spustite nasledujúci príkaz:

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

Tu a ďalej v podobných príkazoch $DOCKER_USER_ID by mal byť nahradený vaším používateľským menom Docker Hub. Táto časť príkazu môže vyzerať napríklad takto: rinormaloku/sentiment-analysis-frontend.

V tomto prípade možno tento príkaz skrátiť odstránením z neho -f Dockerfile, pretože tento súbor už existuje v priečinku, v ktorom vykonávame tento príkaz.

Aby sme mohli poslať hotový obrázok do úložiska, potrebujeme nasledujúci príkaz:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Po dokončení skontrolujte zoznam svojich úložísk na Docker Hub, aby ste pochopili, či bolo nahranie obrázka do cloudového úložiska úspešné.

▍ Prevádzka kontajnera

Teraz si každý môže stiahnuť a spustiť obrázok, známy ako $DOCKER_USER_ID/sentiment-analysis-frontend. Ak to chcete urobiť, musíte spustiť nasledujúcu postupnosť príkazov:

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

Teraz je kontajner spustený, môžeme pokračovať v práci vytváraním ďalších obrázkov, ktoré potrebujeme. Ale skôr ako budeme pokračovať, poďme pochopiť dizajn 80:80, ktorý sa zobrazuje v príkaze na spustenie obrázka a môže pôsobiť mätúco.

• Prvé číslo 80 — toto je číslo portu hostiteľa (to znamená miestny počítač).
• Druhé číslo 80 je prístav kontajnera, na ktorý má byť žiadosť preposlaná.

Zvážte nasledujúci obrázok.

Presmerovanie portov

Systém presmeruje požiadavky z portu <hostPort> do prístavu <containerPort>. Teda prístup do prístavu 80 počítač je presmerovaný na port 80 kontajner.

Od prístavu 80 otvorené na lokálnom počítači, potom môžete pristupovať k aplikácii z tohto počítača na adrese localhost:80. Ak váš systém nepodporuje Docker, aplikáciu je možné spustiť na virtuálnom stroji Docker, ktorého adresa bude vyzerať takto <docker-machine ip>:80. Ak chcete zistiť adresu IP virtuálneho počítača Docker, môžete použiť príkaz docker-machine ip.

V tomto bode, po úspešnom spustení kontajnera front-end aplikácie, by ste mali byť schopní otvoriť jej stránku v prehliadači.

▍Súbor .dockerignore

Zhromažďovanie obrázka aplikácie SA-Frontend, mohli sme si všimnúť, že tento proces je extrémne pomalý. Stáva sa to preto, že kontext vytvárania obrazu musí byť odoslaný démonovi Docker. Adresár predstavujúci kontext zostavenia je špecifikovaný ako posledný argument príkazu docker build. V našom prípade je na konci tohto príkazu bodka. To spôsobí, že do kontextu zostavenia bude zahrnutá nasledujúca štruktúra:

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

Ale zo všetkých tu prítomných priečinkov potrebujeme iba priečinok build. Načítanie čohokoľvek iného je strata času. Zostavovanie môžete urýchliť tak, že Dockerovi poviete, ktoré adresáre má ignorovať. Na to potrebujeme súbor .dockerignore. Vy, ak ste oboznámení so súborom .gitignore, štruktúra tohto súboru sa vám pravdepodobne bude zdať známa. Uvádza zoznamy adresárov, ktoré systém vytvárania obrazu môže ignorovať. V našom prípade obsah tohto súboru vyzerá takto:

node_modules
src
public

súbor .dockerignore musí byť v rovnakom priečinku ako súbor Dockerfile. Vytvorenie obrázka teraz bude trvať niekoľko sekúnd.

Poďme teraz pracovať na obrázku pre aplikáciu Java.

▍Vytvorenie obrazu kontajnera pre aplikáciu Java

Viete čo, už ste sa naučili všetko, čo potrebujete vedieť na vytváranie obrázkov kontajnerov. Preto bude táto časť veľmi krátka.

Otvorte súbor Dockerfilektorý sa nachádza v priečinku projektu sa-webapp. Ak si prečítate text tohto súboru, uvidíte v ňom iba dve nové konštrukcie, počnúc kľúčovými slovami ENV и EXPOSE:

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

Kľúčové slovo ENV Umožňuje deklarovať premenné prostredia v kontajneroch Docker. Najmä v našom prípade vám umožňuje zadať adresu URL na prístup k API aplikácie, ktorá vykonáva analýzu textu.

Kľúčové slovo EXPOSE vám umožňuje povedať Dockerovi, aby otvoril port. Tento port budeme používať pri spustení aplikácie. Tu si môžete všimnúť, že v Dockerfile na aplikáciu SA-Frontend taký príkaz neexistuje. Toto je len na dokumentačné účely, inými slovami, táto konštrukcia je určená pre toho, kto bude čítať Dockerfile.

Vytvorenie obrázka a jeho vloženie do úložiska vyzerá úplne rovnako ako v predchádzajúcom príklade. Ak si ešte nie ste veľmi istý svojimi schopnosťami, zodpovedajúce príkazy nájdete v súbore README.md v priečinku sa-webapp.

▍Vytvorenie obrazu kontajnera pre aplikáciu Python

Ak sa pozriete na obsah súboru Dockerfile v priečinku sa-logic, potom tam nenájdete pre seba nič nové. Príkazy na zostavenie obrazu a jeho odoslanie do úložiska by ste už tiež mali poznať, ale rovnako ako v prípade iných našich aplikácií ich nájdete v súbore README.md v priečinku sa-logic.

▍Testovanie kontajnerových aplikácií

Môžete dôverovať niečomu, čo ste neotestovali? ja tiež nemôžem. Poďme otestovať naše nádoby.

1. Spustíme kontajner aplikácie sa-logic a nakonfigurujte ho tak, aby počúval na porte 5050:

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

2. Spustíme kontajner aplikácie sa-webapp a nakonfigurujte ho tak, aby počúval na porte 8080. Okrem toho musíme nakonfigurovať port, na ktorom bude aplikácia Python načúvať požiadavkám z aplikácie Java opätovným priradením premennej prostredia 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

Ak sa chcete dozvedieť, ako zistiť IP adresu kontajnera Docker alebo virtuálneho počítača, pozrite si súbor README.

Spustíme kontajner aplikácie sa-frontend:

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

Teraz je všetko pripravené prejsť na adresu v prehliadači localhost:80 a vyskúšajte aplikáciu.

Upozorňujeme, že ak ste zmenili port pre sa-webapp, alebo ak máte spustený virtuálny stroj Docker, budete musieť súbor upraviť App.js z priečinka sa-frontendzmenou IP adresy alebo čísla portu v metóde analyzeSentence(), ktoré nahrádzajú aktuálne informácie namiesto neaktuálnych údajov. Potom musíte obrázok znova zostaviť a použiť.

Takto teraz vyzerá náš aplikačný diagram.

Mikroslužby fungujú v kontajneroch

Zhrnutie: prečo potrebujeme klaster Kubernetes?

Práve sme preskúmali súbory Dockerfile, hovoril o tom, ako vytvárať obrázky a posúvať ich do úložiska Docker. Okrem toho sme sa naučili, ako urýchliť zostavovanie obrázkov pomocou súboru .dockerignore. Výsledkom je, že naše mikroslužby teraz bežia v kontajneroch Docker. Tu môžete mať úplne opodstatnenú otázku, prečo potrebujeme Kubernetes. Druhá časť tohto materiálu bude venovaná odpovedi na túto otázku. Medzitým zvážte nasledujúcu otázku:
Predpokladajme, že naša webová aplikácia na analýzu textu sa stala celosvetovo populárnou. Každú minútu k nemu prichádzajú milióny žiadostí. To znamená, že mikroslužby sa-webapp и sa-logic bude pod enormnou záťažou. Ako škálovať kontajnery s mikroslužbami?

Zdroj: hab.com