🥇Průvodce Kubernetes, část 1: aplikace, mikroservice a kontejnery

Na naši žádost Habr vytvořil hub Kubernetes a jsme potěšeni, že můžeme zveřejnit první příspěvek v něm. Sledujte nás!

Kubernetes je jednoduchý. Proč mi ale banky platí velké částky za práci v této oblasti, když se tuto technologii může naučit doslova každý za pár hodin?

Pokud pochybujete, že se Kubernetes dá tak rychle naučit - doporučuji vám to zkusit sami. Tímto, po osvojení tohoto materiálu, budete schopni spustit aplikaci založenou na mikroslužbách v Kubernetes clustru. Můžu to zaručit, protože právě podle metodiky, která je zde použita, učím naše klienty pracovat s Kubernetes. Čím se tento průvodce liší od ostatních? Vlastně mnoha věcmi. Většina podobných materiálů začíná vysvětlením základních pojmů — konceptů Kubernetes a vlastností příkazu kubectl. Autoři těchto materiálů předpokládají, že jejich čtenář je obeznámen s vývojem aplikací, mikroslužbami a kontejnery Docker. My však půjdeme jinou cestou. Nejprve vysvětlíme, jak spustit na počítači aplikaci založenou na mikroslužbách. Pak se zaměříme na sestavení obrazů kontejnerů pro každou mikroslužbu. A až poté se seznámíme s Kubernetes a prozkoumáme nasazení aplikace založené na mikroslužbách v klastru řízeném Kubernetes.

Takový přístup, s postupným přiblížením k Kubernetes, poskytne hloubku porozumění, kterou potřebuje běžný člověk k pochopení, jak jednoduše Kubernetes funguje. Kubernetes je bezpochyby jednoduchá technologie, pokud ten, kdo se ji chce naučit, ví, kde a jak se používá.

Teď, bez zbytečných slov, přejdeme k práci a promluvíme o aplikaci, se kterou budeme pracovat.

Experimentální aplikace

Naše aplikace bude vykonávat pouze jednu funkci. Přijímá jako vstup jednu větu, po čemž, pomocí textové analýzy, provede analýzu sentimentu této věty, přičemž získá hodnocení emocionálního vztahu autora věty k určitému objektu.

Takto vypadá hlavní okno této aplikace.

Webová aplikace pro analýzu sentimentu textů

Z technického hlediska se aplikace skládá ze tří mikroslužeb, z nichž každá řeší určitou sadu úloh:

SA-Frontend — webový server Nginx, který obsluhuje statické soubory React.
SA-WebApp — webová aplikace napsaná v Javě, která zpracovává požadavky z frontendu.
SA-Logic — Python aplikace, která provádí analýzu sentimentu textu.

Je důležité poznamenat, že mikroslužby neexistují v izolaci. Realizují myšlenku 'rozdělení povinností', ale musí vzájemně komunikovat.

Toky dat v aplikaci

Na výše uvedeném schématu lze vidět číslované fáze práce systému, které ilustrují toky dat v aplikaci. Podívejme se na ně:

Prohlížeč žádá server o soubor index.html (který pak načte balíček React aplikace).
Uživatel interaguje s aplikací, což vyvolává volání na webovou aplikaci založenou na Spring.
Webová aplikace přesměruje požadavek k provedení analýzy textu na Python aplikaci.
Python aplikace provádí analýzu sentimentu textu a vrací výsledek jako odpověď na požadavek.
Spring aplikace posílá odpověď zpět React aplikaci (a ta, na oplátku, zobrazuje výsledek analýzy textu uživateli).

Kód pro všechny tyto aplikace lze najít zde. Doporučuji vám hned teď si tento repozitář zkopírovat, protože před námi je mnoho zajímavých experimentů s ním.

Spuštění aplikace založené na mikroslužbách na lokálním počítači

Aby aplikace fungovala, musíme spustit všechny tři mikroslužby. Začneme s tou nejzajímavější z nich — s frontend aplikací.

▍Nastavení React pro lokální vývoj

Abychom spustili React aplikaci, musíte na svém počítači nainstalovat platformu Node.js a NPM. Poté, co to všechno nainstalujete, přejděte pomocí terminálu do složky projektu sa-frontend a spusťte následující příkaz:

npm install

Díky provedení tohoto příkazu budou do složky node_modules staženy závislosti React aplikace, jejichž záznamy jsou v souboru package.json. Po dokončení stahování závislostí v té samé složce zadejte následující příkaz:

npm start

A je to. Nyní je React aplikace spuštěna, přístup k ní můžete získat přechodem do prohlížeče na adresu localhost:3000. Můžete něco změnit v jeho kódu. Efekt těchto změn okamžitě uvidíte v prohlížeči. To je možné díky takzvané „horké“ výměně modulů. Díky tomu se vývoj frontendu stává jednoduchou a příjemnou záležitostí.

▍Příprava aplikace React na produkční nasazení

Pro reálné využití aplikace React je třeba ji převést na sadu statických souborů a poskytovat je klientům pomocí webového serveru.

Pro sestavení aplikace React opět použijte terminál a přejděte do složky sa-frontend a spusťte následující příkaz:

npm run build

To povede ke vytvoření adresáře v projektové složce build. Ten bude obsahovat všechny statické soubory potřebné pro fungování aplikace React.

▍Obsluhování statických souborů pomocí Nginx

Nejprve je nutné nainstalovat a spustit webový server Nginx. Zde můžete jej stáhnout a najít pokyny k instalaci a spuštění. Poté je třeba zkopírovat obsah složky sa-frontend/build do složky [your_nginx_installation_dir]/html.

Při takovém přístupu bude vygenerovaný soubor aplikace React dostupný na adrese index.html [your_nginx_installation_dir]/html/index.html . To je soubor, který server Nginx ve výchozím nastavení poskytuje, když je k němu přistupováno. Server je nakonfigurován k naslouchání na portu, ale lze jej nastavit podle vašich potřeb úpravou souboru 80[your_nginx_installation_dir]/conf/nginx.conf Nyní otevřete prohlížeč a přejděte na adresu.

. Uvidíte stránku aplikace React. localhost:80Aplikace React obsluhovaná serverem Nginx

Pokud teď něco napíšete do pole

Type your sentence a stisknete tlačítko Send — nic se nestane. Ale pokud nahlédnete do konzole, můžete tam vidět zprávy o chybách. Abychom pochopili, kde se tyto chyby vyskytují, prozkoumáme kód aplikace. ▍Analýza kódu front-end aplikace

Pohledem na kód souboru

, můžeme vidět, že stisknutí tlačítka App.jsanalyzeSentence() — nic se nestane. Ale pokud nahlédnete do konzole, můžete tam vidět zprávy o chybách. Abychom pochopili, kde se tyto chyby vyskytují, prozkoumáme kód aplikace. volá metodu . Kód této metody je uveden níže. Všimněte si, že k každému řádku, ke kterému existuje komentář, typu, je uvedeno vysvětlení níže kódu. Takto budeme analyzovat i další úryvky 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. URL, na kterou se provádí POST požadavek. Předpokládá se, že na této adrese je aplikace, která očekává podobné požadavky.

2.Tělo požadavku, které je odesíláno aplikaci. Zde je příklad těla požadavku:

{
    sentence: "I like yogobella!"
}

3.Při obdržení odpovědi na požadavek se aktualizuje stav komponentu. To vyvolá opětovný rendering komponentu. Pokud obdržíme data (tj. JSON objekt obsahující zadané údaje a vypočtené hodnocení textu), zobrazíme komponentu Polarity, jsou-li splněny příslušné podmínky. Zde je, jak popisujeme komponent:

const polarityComponent = this.state.polarity !== undefined ?
     :
    null;

Kód se zdá být plně funkční. Co je tedy špatně? Pokud předpokládáte, že na adrese, na kterou se aplikace pokouší odeslat POST požadavek, zatím není nic, co by tento požadavek mohlo přijmout a zpracovat, máte naprostou pravdu. A konkrétně pro zpracování požadavků, které přicházejí na adresu http://localhost:8080/sentiment, potřebujeme spustit webovou aplikaci založenou na Spring.

Potřebujeme aplikaci Spring, která je schopná přijmout POST požadavek

▍Nastavení webové aplikace založené na Spring

Pro nasazení aplikace Spring budete potřebovat JDK8 a Maven a správně nastavené proměnné prostředí. Jakmile toto všechno nainstalujete, můžete pokračovat v práci na našem projektu.

▍Zabalení aplikace do jar souboru

Přejděte pomocí terminálu do složky sa-webapp a zadejte následující příkaz:

mvn install

Po provedení tohoto příkazu se ve složce sa-webapp vytvoří adresář target. Zde se bude nacházet Java aplikace zabalená do jar souboru, představovaná souborem sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Spuštění Java aplikace

Přejděte do složky target a spusťte aplikaci následujícím příkazem:

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

Během provádění tohoto příkazu dojde k chybě. Abychom začali s jejím opravováním, můžeme analyzovat detaily výjimky v těchto stopách zásobníku:

Chyba při vytváření bean s názvem 'sentimentController': Injikování autowire závislostí selhalo; vnořená výjimka je java.lang.IllegalArgumentException: Nebylo možné vyřešit zástupný znak 'sa.logic.api.url' v hodnotě "${sa.logic.api.url}"

Pro nás je tady nejdůležitější zmínka o nemožnosti zjistit hodnotu sa.logic.api.url. Analyzujme kód, ve kterém dochází k chybě.

▍Analýza Java aplikace

Toto je fragment kódu, ve kterém dochází k chybě.

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

VsentimentController je pole saLogicApiUrl. Jeho hodnota je nastavena na základě vlastnosti sa.logic.api.url.
Řádek saLogicApiUrl doplňuje se hodnotou /analyse/sentiment. Společně tvoří adresu pro volání mikroslužby, která provádí analýzu textu.

▍Nastavení hodnoty vlastnosti

Ve Springu je standardním zdrojem hodnot vlastností soubor application.properties, který lze nalézt na adrese sa-webapp/src/main/resources. Ale jeho použití není jediný způsob, jak nastavit hodnoty vlastností. Můžete to také provést pomocí příkazu následujícího typu:

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

Hodnota této vlastnosti by měla ukazovat na adresu naší aplikace Python.

Nastavením této hodnoty informujeme webovou aplikaci Spring, kam se má obracet pro provádění požadavků na analýzu textu.

Abychom si to zbytečně nezkomplikovali, rozhodneme se, že aplikace Python bude dostupná na adrese localhost:5000 a pokusíme se na to nezapomenout. Výsledný příkaz pro spuštění aplikace Spring bude vypadat takto:

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

V našem systému chybí aplikace Python

Teď už stačí jen spustit aplikaci Python a systém bude fungovat, jak se očekává.

▍Nastavení aplikace Python

Abychom mohli spustit aplikaci Python, musíte mít nainstalovaný Python 3 a Pip a správně nastavené odpovídající proměnné prostředí.

▍Instalace závislostí

Přejděte do složky projektu sa-logic/sa a proveďte následující příkazy:

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

▍Spuštění aplikace

Po instalaci závislostí jsme připraveni spustit aplikaci:

python sentiment_analysis.py

Po vykonání této příkazu nám bude oznámeno následující:

* Spuštění na http://0.0.0.0:5000/ (Stiskněte CTRL+C pro ukončení)

To znamená, že aplikace je spuštěna a čeká na požadavky na adrese localhost:5000/

▍Prozkoumání kódu

Podíváme se na kód Pythonové aplikace, abychom pochopili, jak reaguje na požadavky:

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

Inicializace objektu Flask.
Nastavení adresy pro provádění POST požadavků.
Získání vlastnosti sentence z těla požadavku.
Inicializace anonymního objektu TextBlob a získání hodnoty polarity pro první větu přijatou v těle požadavku (v našem případě je to jediná věta předaná k analýze).
Vrátí odpověď, jejíž tělo obsahuje text věty a vypočítanou hodnotu pro ni polarity.
Spuštění Flask aplikace, která bude dostupná na adrese 0.0.0.0:5000 (můžete k ní přistupovat také pomocí konstrukce typu localhost:5000).

Nyní jsou mikroslužby, které tvoří aplikaci, spuštěny. Jsou nastaveny na vzájemnou interakci. Takto vypadá schéma aplikace v tomto stadiu.

Všechny mikroslužby, které aplikaci tvoří, jsou uvedeny do funkčního stavu

Nyní, než budeme pokračovat, otevřete React aplikaci v prohlížeči a pokuste se analyzovat nějakou větu. Pokud je vše správně, po stisknutí tlačítka — nic se nestane. Ale pokud nahlédnete do konzole, můžete tam vidět zprávy o chybách. Abychom pochopili, kde se tyto chyby vyskytují, prozkoumáme kód aplikace. uvidíte výsledky analýzy pod textovým polem.

V následující části si povíme, jak spustit naše mikroslužby v kontejnerech Docker. To je nezbytné k přípravě aplikace na spuštění v clusteru Kubernetes.

Docker kontejnery

Kubernetes — je to systém pro automatizaci nasazení, škálování a správu kontejnerizovaných aplikací. Říká se jí také "orchestrátor kontejnerů" (container orchestrator). Pokud Kubernetes pracuje s kontejnery, musíme si nejprve tyto kontejnery opatřit, než začneme tento systém používat. Ale nejprve si pojďme říct, co to vlastně kontejnery jsou. Snad nejlepší odpověď na otázku, co to je, lze nalézt v dokumentaci Dockeru:

Obraz kontejneru je lehký, autonomní, spustitelný balíček, který obsahuje určitou aplikaci a zahrnuje vše potřebné pro její spuštění: kód aplikace, prostředí pro běh, systémové nástroje a knihovny, nastavení. Kontejnerizované programy mohou být používány v prostředích Linux a Windows a vždy budou fungovat stejně, nezávisle na infrastruktuře.

To znamená, že kontejnery lze spouštět na libovolných počítačích, včetně produkčních serverů, a v jakémkoli prostředí, kde se nacházejí, budou aplikace fungovat totožně.

Abychom prozkoumali zvláštnosti kontejnerů a porovnali je s jinými způsoby spuštění aplikací, podíváme se na příklad obsluhy React aplikace pomocí virtuálního stroje a kontejneru.

▍Obsluha statických souborů React aplikace pomocí virtuálního stroje

Když se pokusíme organizovat obsluhu statických souborů pomocí virtuálních strojů, narazíme na následující nevýhody:

Ineffektivní využívání zdrojů, protože každý virtuální stroj představuje plnohodnotný operační systém.
Závislost na platformě. To, co funguje na určitém lokálním počítači, nemusí nutně fungovat na produkčním serveru.
Pomalé a náročné na zdroje škálování řešení založeného na virtuálních strojích.

Webový server Nginx obsluhující statické soubory spuštěný na virtuálním stroji

Pokud byste na podobný úkol použili kontejnery, můžete si všimnout následujících jejich silných stránek v porovnání s virtuálními stroji:

Efektivní využívání zdrojů: práce s operačním systémem pomocí Dockeru.
Nezávislost na platformě. Kontejnér, který může vývojář spustit na svém počítači, bude fungovat kdekoli.
Lehké nasazení díky použití vrstev obrazů.

Webový server Nginx, který obsluhuje statické soubory, spuštěný v kontejneru.

Porovnali jsme virtuální stroje a kontejnery pouze v několika ohledech, ale i to stačí k tomu, abychom pocítili silné stránky kontejnerů. Zde podrobnosti o kontejnerech Docker.

▍Sestavení obrazu kontejneru pro aplikaci React

Hlavní součástí kontejneru Docker je soubor Dockerfile. Na začátku tohoto souboru se uvádí základní obraz kontejneru, poté se sem zahrnou sekvence příkazů určující pořadí vytváření kontejneru, který bude vyhovovat potřebám určité aplikace.

Než se pustíme do práce se souborem Dockerfile, připomeňme si, co jsme dělali pro přípravu souborů aplikace React k vydání na serveru Nginx:

Sestavení balíčku aplikace React (npm run build).
Spuštění serveru Nginx.
Kopírování obsahu adresáře build z adresáře projektu sa-frontend do složky serveru nginx/html.

Níže uvidíte paralely mezi vytvářením kontejneru a výše popsanými akcemi prováděnými na lokálním počítači.

▍Příprava souboru Dockerfile pro aplikaci SA-Frontend

Pokyny, které budou obsaženy v Dockerfile pro aplikaci , která obsluhuje frontend aplikace na Reactjs;, se skládají pouze ze dvou příkazů. Skupina vývojářů Nginx připravila základní obraz pro Nginx, který použijeme k vytvoření našeho obrazu. Zde jsou dva kroky, které musíme popsat:

Základem obrazu musí být obraz Nginx.
Obsah složky sa-frontend/build je třeba zkopírovat do složky obrazu nginx/html.

Pokud přejdete od tohoto popisu k souboru Dockerfile, bude vypadat takto:

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

Jak vidíte, je to velmi jednoduché, přičemž obsah souboru je poměrně čitelný a srozumitelný. Tento soubor říká systému, aby vzal obraz nginx se vším, co již obsahuje, a zkopíroval obsah adresáře build do adresáře nginx/html.

Může vás zajímat otázka, odkud vím, kam přesně mám kopírovat soubory ze složky build, tedy odkud pochází cesta /usr/share/nginx/html. Ve skutečnosti v tom není nic složitého. Odpovídající informace lze nalézt v popisu obrazu.

▍Sestavení obrazu a jeho nahrání do repozitáře

Než budeme moci pracovat s hotovým obrazem, musíme jej odeslat do repozitáře obrazů. K tomu využijeme bezplatnou cloudovou platformu pro hostování obrazů Docker Hub. V této fázi práce je potřeba udělat následující:

Nainstalovat Docker.
Registrovat se na webu Docker Hub.
Přihlásit se do účtu spuštěním příkazu následujícího tvaru v terminálu:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Nyní je potřeba pomocí terminálu přejít do adresáře sa-frontend a tam provést příkaz následujícího tvaru:

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

Tady a dále v podobných příkazech $DOCKER_USER_ID je třeba nahradit vaším uživatelským jménem na Docker Hub. Například, tato část příkazu může vypadat takto: rinormaloku/sentiment-analysis-frontend.

Tento příkaz lze zkrátit, pokud odstraníme -f Dockerfile, protože ve složce, ve které tento příkaz provádíme, je tento soubor již přítomen.

Pro odeslání hotového obrazu do repozitáře budeme potřebovat takový příkaz:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Po jeho provedení zkontrolujte seznam svých repozitářů na Docker Hub, abyste zjistili, zda se obraz úspěšně odeslal do cloudového úložiště.

▍Spuštění kontejneru

Nyní si může kdokoli stáhnout a spustit obraz známý jako $DOCKER_USER_ID/sentiment-analysis-frontend. Pro to je potřeba provést následující sekvenci příkazů:

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

Nyní je kontejner spuštěn a můžeme pokračovat v práci vytvářením dalších potřebných obrazů. Ale předtím, než budeme pokračovat, pojďme se podívat na konstrukci 80:80, která se v příkazu pro spuštění obrazu objevuje a může se zdát nejasná.

První číslo 80 je číslo portu hostitele (to znamená – místního počítače).
Druhé číslo 80 je port kontejneru, na který by měla být přesměrována žádost.

Podívejme se na následující ilustraci.

Přesměrování portů

Systém přesměrovává žádosti z portu <hostPort> na port <containerPort>. To znamená, že požadavek na port 80 počítače je přesměrován na port 80 kontejneru.

Jelikož je port 80 otevřen na místním počítači, lze k aplikaci z tohoto počítače přistupovat na adrese localhost:80. Pokud vaše systém Docker nepodporuje, můžete aplikaci spustit na virtuální Docker stroji, jehož adresa bude vypadat jako :80. Abychom zjistili IP adresu virtuálního Docker stroje, můžeme použít příkaz docker-machine ip.

V této fázi, po úspěšném spuštění kontejneru frontendové aplikace, byste měli mít možnost otevřít její stránku v prohlížeči.

▍Soubor .dockerignore

Při vytváření obrazu aplikace , která obsluhuje frontend aplikace na Reactjs;, jsme si mohli všimnout, že tento proces může být velmi pomalý. Děje se tak proto, že démonu Docker musí být poslán kontext pro sestavení obrazu. Adresář, který představuje kontext sestavení, je určen jako poslední argument příkazu docker build. V našem případě se na konci tohoto příkazu nachází tečka. To vede k tomu, že do kontextu sestavení je zahrnuta následující struktura:

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

Ale z všech složek zde potřebujeme pouze složku build. Nahrávání čehokoli jiného je zbytečná ztráta času. Sestavení můžeme urychlit tím, že Dockeru řekneme, které adresáře může ignorovat. Právě kvůli tomu potřebujeme soubor .dockerignore. Pokud znáte soubor .gitignore, struktura tohoto souboru vám jistě bude povědomá. Obsahuje seznam adresářů, které může systém pro sestavení obrazu ignorovat. V našem případě vypadá obsah tohoto souboru takto:

node_modules
src
public

Soubor .dockerignore musí být ve stejné složce jako soubor Dockerfile. Nyní bude sestavení obrazu trvat jen několik sekund.

Nyní se zaměříme na obraz pro Java aplikaci.

▍Sestavení obrazu kontejneru pro Java aplikaci

Vídejte, už jste se naučili vše potřebné pro vytváření obrazů kontejnerů. Proto bude tato část velmi krátká.

Otevřete soubor Dockerfile, který se nachází ve složce projektu sa-webapp. Pokud si přečtete text tohoto souboru, narazíte na dvě nové konstrukce, které začínají klíčovými slovy ENV a EXPOSE:

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

Klíčové slovo ENV umožňuje deklarovat proměnné prostředí uvnitř kontejnerů Docker. V našem případě to umožňuje nastavit URL pro přístup k API aplikace, která provádí analýzu textu.

Klíčové slovo EXPOSE umožňuje Dockeru vědět, že port je třeba otevřít. Tento port budeme používat během práce s aplikací. Můžeme si povšimnout, že v Dockerfile pro aplikaci , která obsluhuje frontend aplikace na Reactjs; takový příkaz neexistuje. Je to pouze pro dokumentační účely, jinými slovy, tato konstrukce je určena pro ty, kdo budou číst Dockerfile.

Sestavení obrazu a jeho odeslání do repozitáře vypadá přesně jako v předchozím příkladu. Pokud si však nejste jisti svými schopnostmi, příslušné příkazy najdete v souboru README.md ve složce sa-webapp.

▍Sestavení obrazu kontejneru pro Python aplikaci

Pokud se podíváte na obsah souboru Dockerfile ve složce sa-logic, nic nového tam nenajdete. Příkazy pro sestavení obrazu a jeho odeslání do repozitáře vám také musí být známé, ale ty, jako v případě našich dalších aplikací, lze najít v souboru README.md ve složce sa-logic.

▍Testování kontejnerizovaných aplikací

Můžete něčemu věřit, co jste netestovali? Já také ne. Otestujeme naše kontejnery.

Spustíme kontejner aplikace sa-logic a nastavíme jej na naslouchání portu 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Spustíme kontejner aplikace sa-webapp a nastavíme jej na naslouchání portu 8080. Kromě toho musíme nastavit port, na kterém Python aplikace bude čekat na požadavky od Java aplikace, předefinováním proměnné prostředí SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Abyste se dozvěděli, jak zjistit IP adresu kontejneru nebo virtuálního stroje Docker — podívejte se do souboru README.

Spustíme kontejner aplikace sa-frontend:

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

Nyní je vše připraveno k tomu, abyste v prohlížeči navštívili adresu localhost:80 a otestovali aplikaci.

Všimněte si, že pokud jste změnili port pro sa-webapp, nebo pokud pracujete s virtuálním strojem Docker, budete muset upravit soubor App.js z adresáře sa-frontend, změnit IP adresu nebo číslo portu v metodě . Kód této metody je uveden níže. Všimněte si, že k každému řádku, ke kterému existuje komentář, typu, a nahradit zastaralé údaje aktuálními informacemi. Poté je potřeba znovu sestavit obraz a použít jej.

Takto nyní vypadá schéma naší aplikace.

Mikroslužby běží v kontejnerech

Závěry: proč potřebujeme Kubernetes klastr?

Právě jsme prozkoumali soubory Dockerfile, diskutovali o tom, jak sestavovat obrazy a odesílat je do repozitáře Docker. Dále jsme se naučili urychlit sestavení obrazů pomocí souboru .dockerignoreNakonec naše mikroservice nyní běží v kontejnerech Docker. Může se vám zcela oprávněně vyskytnout otázka, proč potřebujeme Kubernetes. Tato otázka bude předmětem druhé části tohoto materiálu. A zatím se zamyslete nad následující otázkou:
Předpokládejme, že naše webová aplikace pro analýzu textů se stala celosvětově populární. Každou minutu se k ní dostávají miliony požadavků. To znamená, že mikroservice sa-webapp a sa-logic budou pod ohromnou zátěží. Jak škálovat kontejnery, ve kterých běží mikroservice?

Zdroj: habr.com