Kurz Kubernetes, část 1: Aplikace, mikroslužby a kontejnery

Na naši žádost Habr vytvořil hub Kubernetes a jsme rádi, že do ní můžeme umístit první publikaci. Předplatit!

Kubernetes je snadný. Proč mi banky platí velké peníze za práci v této oblasti, zatímco tuto technologii zvládne každý za pár hodin?

Pokud pochybujete o tom, že se Kubernetes lze naučit tak rychle, doporučuji, abyste to zkusili sami. Totiž po zvládnutí tohoto materiálu budete moci spouštět aplikaci založenou na mikroslužbách v clusteru Kubernetes. To mohu zaručit, protože právě ve stejné metodice, kterou používám zde, učím naše klienty pracovat s Kubernetes. Čím se tato příručka liší od ostatních? Vlastně hodně věcí. Většina těchto materiálů tedy začíná vysvětlením jednoduchých věcí – konceptů Kubernetes a funkcí příkazu kubectl. Autoři těchto článků předpokládají, že jejich čtenář je obeznámen s vývojem aplikací, mikroslužbami a kontejnery Docker. Půjdeme jinou cestou. Nejprve si povíme, jak spustit aplikaci založenou na mikroslužbách na počítači. Poté se podíváme na vytváření obrázků kontejnerů pro každou mikroslužbu. A poté se seznámíme s Kubernetes a rozebereme nasazení aplikace založené na mikroslužbách v clusteru spravovaném Kubernetes.

Tento přístup s postupným přístupem ke Kubernetes poskytne hloubku pochopení toho, co se děje, kterou průměrný člověk potřebuje, aby pochopil, jak jednoduše je vše v Kubernetes uspořádáno. Kubernetes je jistě jednoduchá technologie za předpokladu, že kdo ji chce ovládat, ví, kde a jak se používá.

Nyní se bez dalších řečí pustíme do práce a promluvme si o aplikaci, se kterou budeme pracovat.

Experimentální aplikace

Naše aplikace bude plnit pouze jednu funkci. Jako vstup si vezme jednu větu, načež pomocí nástrojů textové analýzy provede sentimentální analýzu této věty, čímž získá posouzení emocionálního postoje autora věty k určitému předmětu.

Takto vypadá hlavní okno této aplikace.

Webová aplikace Analýza sentimentu

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

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

Je důležité si uvědomit, že mikroslužby neexistují izolovaně. Implementují myšlenku „oddělení povinností“, ale zároveň musí vzájemně komunikovat.

Datové toky v aplikaci

Ve výše uvedeném diagramu můžete vidět očíslované fáze systému, které ilustrují datové toky v aplikaci. Pojďme si je rozebrat:

1. Prohlížeč požaduje soubor ze serveru index.html (což zase načte balíček aplikace React).
2. Uživatel interaguje s aplikací, což způsobí volání webové aplikace založené na Spring.
3. Webová aplikace předá požadavek na analýzu textu do aplikace Python.
4. Aplikace Python analyzuje sentiment textu a vrátí výsledek jako odpověď na požadavek.
5. Aplikace Spring odešle odpověď do aplikace React (která zase zobrazí výsledek analyzovaného textu uživateli).

Kód všech těchto aplikací lze nalézt zde. Doporučuji, abyste si toto úložiště zkopírovali pro sebe hned teď, protože je před námi mnoho zajímavých experimentů s ním.

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

Aby aplikace fungovala, musíme spustit všechny tři mikroslužby. Začněme tou nejhezčí z nich – front-end aplikací.

▍Nastavení Reactu pro místní rozvoj

Abyste mohli spustit aplikaci React, musíte do počítače nainstalovat framework Node.js a NPM. Po instalaci tohoto všeho přejděte pomocí terminálu do složky projektu sa-frontend a spusťte následující příkaz:

npm install

Spuštěním tohoto příkazu ve složce node_modules načtou se závislosti aplikace React, jejíž záznamy jsou v souboru package.json. Po stažení závislostí do stejné složky spusťte následující příkaz:

npm start

To je vše. Aplikace React je nyní spuštěna a lze k ní přistupovat přechodem na adresu prohlížeče localhost:3000. Můžete něco změnit v jeho kódu. Okamžitě uvidíte účinek těchto změn v prohlížeči. To je možné díky tzv. „horké“ výměně modulů. Díky tomu se front-endový vývoj promění v jednoduchý a příjemný zážitek.

▍Příprava aplikace React pro produkci

Abychom mohli skutečně používat aplikaci React, musíme ji převést na sadu statických souborů a poskytovat je klientům pomocí webového serveru.

Chcete-li sestavit aplikaci React, znovu pomocí terminálu přejděte do složky sa-frontend a spusťte následující příkaz:

npm run build

Tím se vytvoří adresář ve složce projektu build. Bude obsahovat všechny statické soubory potřebné pro fungování aplikace React.

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

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

S tímto přístupem soubor vygenerovaný během sestavování aplikace React index.html bude k dispozici na [your_nginx_installation_dir]/html/index.html. Toto je soubor, který ve výchozím nastavení server Nginx vydává při přístupu k němu. Server je nakonfigurován tak, aby naslouchal na portu 80, ale můžete si jej upravit tak, jak chcete, úpravou souboru [your_nginx_installation_dir]/conf/nginx.conf.

Nyní otevřete prohlížeč a přejděte na localhost:80. Zobrazí se stránka aplikace React.

Aplikace React obsluhovaná serverem Nginx

Pokud nyní něco zadáte do pole Type your sentence a stiskněte tlačítko Send - nic se nestane. Pokud se však podíváte na konzolu, můžete tam vidět chybové zprávy. Abychom přesně pochopili, kde se tyto chyby vyskytují, pojďme analyzovat kód aplikace.

▍Analýza kódu front-endové aplikace

Při pohledu na kód souboru App.js, můžeme vidět kliknutí na tlačítko Send volá metodu analyzeSentence(). Kód této metody je uveden níže. Zároveň si dejte pozor na to, aby u každého řádku, ke kterému je komentář formuláře # Номер, pod kódem je uvedeno vysvětlení. Stejným způsobem budeme analyzovat další 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 kterou je odeslán požadavek POST. Předpokládá se, že tato adresa je aplikací čekající na takové požadavky.

2.Požadavek odeslaný do aplikace. Zde je příklad těla požadavku:

{
    sentence: "I like yogobella!"
}

3.Když je přijata odpověď na požadavek, aktualizuje se stav komponenty. To způsobí, že se komponenta znovu vykreslí. Pokud obdržíme data (tedy JSON objekt obsahující zadaná data a vypočtené textové skóre), vypíšeme komponentu Polaritypokud jsou splněny podmínky. Komponentu popisujeme takto:

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

Zdá se, že kód funguje docela dobře. Co je tady vůbec š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, pak budete mít naprostou pravdu. Konkrétně ke zpracování žádostí přicházejících na adresu http://localhost:8080/sentiment, potřebujeme spustit webovou aplikaci založenou na Spring.

Potřebujeme aplikaci Spring, která dokáže přijmout požadavek POST

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

Abyste mohli nasadit aplikaci Spring, potřebujete JDK8 a Maven a správně nakonfigurované proměnné prostředí. Po instalaci tohoto všeho můžete pokračovat v práci na našem projektu.

▍Zabalení aplikace do souboru jar

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

mvn install

Po provedení tohoto příkazu ve složce sa-webapp bude vytvořen adresář target. Zde se bude nacházet Java aplikace zabalená v souboru jar, který tento soubor představuje sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Spuštění aplikace Java

Přejít do složky target a spusťte aplikaci pomocí následujícího příkazu:

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

Při provádění tohoto příkazu dojde k chybě. Chcete-li to začít opravovat, můžeme analyzovat podrobnosti o výjimce v datech trasování zásobníku:

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

Pro nás je zde nejdůležitější zmínka o nemožnosti objasnění významu sa.logic.api.url. Pojďme analyzovat kód, kde se chyba vyskytuje.

▍Analýza kódu aplikace Java

Zde je fragment kódu, kde došlo 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();
    }
}

1. V SentimentController tam je pole saLogicApiUrl. Jeho hodnotu určuje vlastnost sa.logic.api.url.
2. Řetězec saLogicApiUrl spojuje s hodnotou /analyse/sentiment. Společně tvoří adresu pro volání mikroslužby, která provádí analýzu textu.

▍Nastavení hodnoty vlastnosti

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

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.

Nakonfigurováním sdělíme webové aplikaci Spring, kam má jít, aby provedla požadavky na analýzu textu.

Abychom si nekomplikovali život, rozhodneme se, že aplikace Python bude dostupná na localhost:5000 a snažte se na to nezapomenout. V důsledku toho bude příkaz ke spuštění aplikace Spring 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

Nyní stačí spustit aplikaci Python a systém bude fungovat podle očekávání.

▍Nastavení aplikace Python

Abyste mohli spustit aplikaci Python, musíte mít nainstalované Python 3 a Pip a musíte mít správně nastavené příslušné proměnné prostředí.

▍Nainstalujte závislosti

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

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

▍Spuštění aplikace

S nainstalovanými závislostmi jsme připraveni spustit aplikaci:

python sentiment_analysis.py

Po provedení tohoto příkazu nám bude sděleno následující:

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

To znamená, že aplikace běží a čeká na požadavky na localhost:5000/

▍Výzkum kódu

Podívejme se na kód aplikace Python, 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

1. Inicializace objektu Flask.
2. Zadání adresy pro odesílání požadavků POST na ni.
3. Načítání nemovitosti sentence z těla žádosti.
4. Inicializace anonymního objektu TextBlob a získání hodnoty polarity za první návrh doručený v těle žádosti (v našem případě se jedná o jediný návrh předložený k analýze).
5. Vrácení odpovědi, jejíž tělo obsahuje text nabídky a pro ni vypočítaný ukazatel polarity.
6. Spuštění aplikace Flask, která bude dostupná na 0.0.0.0:5000 (můžete k němu také přistupovat pomocí konstrukce formuláře localhost:5000).

Nyní běží mikroslužby, které tvoří aplikaci. Jsou nastaveny na vzájemnou interakci. Takto vypadá aplikační diagram v této fázi práce.

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

Nyní, než budeme pokračovat, otevřete aplikaci React v prohlížeči a zkuste s ní analyzovat nějakou větu. Pokud je vše provedeno správně - po stisknutí tlačítka Send výsledky analýzy uvidíte pod textovým polem.

V další části si povíme, jak provozovat naše mikroslužby v kontejnerech Docker. To je nezbytné pro přípravu aplikace ke spuštění v clusteru Kubernetes.

Docker kontejnery

Kubernetes je systém pro automatizaci nasazení, škálování a správy kontejnerových aplikací. Říká se mu také „kontejnerový orchestrátor“. Pokud Kubernetes pracuje s kontejnery, pak před použitím tohoto systému musíme tyto kontejnery nejprve pořídit. Nejprve si ale řekněme, co to kontejnery jsou. Možná nejlepší odpověď na otázku, co to je, najdete v dokumentace do Dockeru:

Obraz kontejneru je lehký, samostatný spustitelný balíček, který obsahuje aplikaci, která obsahuje vše potřebné k jejímu spuštění: kód aplikace, běhové prostředí, systémové nástroje a knihovny, nastavení. Kontejnerové programy lze používat v prostředí Linux i Windows a budou vždy fungovat stejně bez ohledu na infrastrukturu.

To znamená, že kontejnery lze spouštět na jakémkoli počítači, včetně produkčních serverů, a v jakémkoli prostředí budou aplikace v nich uzavřené fungovat stejně.

Chcete-li prozkoumat funkce kontejnerů a porovnat je s jinými způsoby spouštění aplikací, podívejme se na příklad obsluhy aplikace React pomocí virtuálního počítače a kontejneru.

▍Poskytování statických souborů aplikace React pomocí virtuálního počítače

Při pokusu o organizaci údržby statických souborů pomocí virtuálních strojů narazíme na následující nevýhody:

1. Neefektivní využití zdrojů, protože každý virtuální stroj je kompletní operační systém.
2. Závislost na platformě. To, co funguje na některém místním počítači, nemusí fungovat na produkčním serveru.
3. Pomalé a na zdroje náročné škálování řešení virtuálního stroje.

Webový server Nginx obsluhující statické soubory běžící na virtuálním počítači

Pokud se k řešení podobného problému používají kontejnery, lze ve srovnání s virtuálními stroji zaznamenat následující silné stránky:

1. Efektivní využití zdrojů: práce s operačním systémem pomocí Dockeru.
2. Nezávislost na platformě. Kontejner, který může vývojář spustit na svém vlastním počítači, poběží kdekoli.
3. Snadné nasazení díky použití obrazových vrstev.

Webový server Nginx obsluhující statické soubory běžící v kontejneru

Virtuální stroje a kontejnery jsme porovnávali pouze v několika bodech, ale i to stačí k tomu, abychom získali představu o silných stránkách kontejnerů. Zde Podrobnosti o kontejnerech Docker naleznete.

▍Vytvoření obrázku kontejneru pro aplikaci React

Základním stavebním kamenem kontejneru Docker je soubor Dockerfile. Na začátku tohoto souboru je zaznamenán základní obrázek kontejneru, poté je zahrnuta sekvence instrukcí, které ukazují, jak vytvořit kontejner, který bude splňovat potřeby aplikace.

Než začneme pracovat se souborem Dockerfile, pamatujte, co jsme udělali, abychom připravili soubory aplikace React pro nahrání na server Nginx:

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

Níže můžete vidět paralely mezi vytvořením kontejneru a výše uvedenými akcemi prováděnými na místním počítači.

▍Příprava Dockerfile pro aplikaci SA-Frontend

Pokyny, které mají být součástí Dockerfile pro aplikaci SA-Frontend, sestávají pouze ze dvou týmů. Faktem je, že vývojový tým Nginx připravil zákl obraz pro Nginx, který použijeme k budování naší image. Zde jsou dva kroky, které musíme popsat:

1. Musíte udělat obrázek Nginx základem obrázku.
2. Obsah složky sa-frontend/build je třeba zkopírovat do složky s obrázky nginx/html.

Přejdeme-li od tohoto popisu k souboru Dockerfile, pak to bude vypadat takto:

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

Jak vidíte, vše je zde velmi jednoduché, zatímco obsah souboru se dokonce ukáže jako docela čitelný a srozumitelný. Tento soubor říká systému, aby pořídil snímek nginx se vším, co již má, a zkopírujte obsah adresáře build do adresáře nginx/html.

Zde můžete mít otázku ohledně toho, jak vím, kam přesně zkopírovat soubory ze složky build, tj. odkud se vzala cesta /usr/share/nginx/html. Ve skutečnosti ani zde není nic složitého. Faktem je, že relevantní informace lze nalézt v popis obraz.

▍ Sestavení obrázku a jeho nahrání do úložiště

Než budeme moci pracovat s dokončeným obrázkem, musíme jej odeslat do úložiště obrázků. K tomu použijeme bezplatnou cloudovou platformu pro hostování obrázků Docker Hub. V této fázi práce musíte udělat následující:

1. Chcete-li nainstalovat přístavní dělník.
2. Zaregistrujte se na webu Docker Hub.
3. Přihlaste se ke svému účtu spuštěním následujícího příkazu v terminálu:

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

Nyní musíte pomocí terminálu přejít do adresáře sa-frontend a tam spusťte následující příkaz:

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

Zde a níže v podobných příkazech $DOCKER_USER_ID by měl být nahrazen vaším uživatelským jménem na Docker Hub. Tato část příkazu může vypadat například takto: rinormaloku/sentiment-analysis-frontend.

V tomto případě lze tento příkaz zkrátit odebráním z něj -f Dockerfile, protože složka, ve které provádíme tento příkaz, již tento soubor obsahuje.

Abychom mohli odeslat hotový obrázek do úložiště, potřebujeme následující příkaz:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Po jeho dokončení zkontrolujte svůj seznam úložišť na Docker Hub a zjistěte, zda byl obrázek úspěšně odeslán do cloudového úložiště.

▍Spuštění kontejneru

Nyní si každý může stáhnout a spustit obrázek známý jako $DOCKER_USER_ID/sentiment-analysis-frontend. Chcete-li to provést, musíte spustit následující posloupnost 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 my můžeme pokračovat v práci vytvářením dalších obrázků, které potřebujeme. Ale než budeme pokračovat, pojďme pochopit design 80:80, který se nachází v příkazu ke spuštění obrazu a může se zdát matoucí.

• První číslo 80 je číslo portu hostitele (tj. místního počítače).
• Druhé číslo 80 je port kontejneru, na který má být požadavek přesměrován.

Zvažte následující obrázek.

Přesměrování portů

Systém předává požadavky z portu <hostPort> do přístavu <containerPort>. Tedy přístup k portu 80 počítač je přesměrován na port 80 kontejner.

Od přístavu 80 otevřete na místním počítači, můžete k aplikaci přistupovat z tohoto počítače na adrese localhost:80. Pokud váš systém nepodporuje Docker, můžete aplikaci spustit na virtuálním počítači Docker, jehož adresa bude vypadat takto <docker-machine ip>:80. Chcete-li zjistit IP adresu virtuálního počítače Docker, můžete použít příkaz docker-machine ip.

V tomto okamžiku, jakmile se kontejner front-endové aplikace úspěšně spustí, měli byste být schopni otevřít jeho stránku v prohlížeči.

▍.dockerignore soubor

Vytváření image aplikace SA-Frontend, mohli jsme si všimnout, že tento proces je extrémně pomalý. Důvodem je, že kontext sestavení obrazu musí být odeslán démonu Docker. Adresář, který představuje kontext sestavení, je uveden jako poslední argument příkazu docker build. V našem případě je na konci tohoto příkazu tečka. Výsledkem je zahrnutí následující struktury do kontextu sestavení:

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

Ale ze všech zde přítomných složek potřebujeme pouze složku build. Stahování čehokoli jiného je ztráta času. Sestavení můžete urychlit tím, že sdělíte Dockeru, které adresáře má ignorovat. K tomu potřebujeme soubor .dockerignore. Vy, pokud jste obeznámeni se souborem .gitignore, bude struktura tohoto souboru pravděpodobně vypadat povědomě. Uvádí adresáře, které systém pro tvorbu obrazu může ignorovat. V našem případě obsah tohoto souboru vypadá takto:

node_modules
src
public

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

Pojďme se nyní zabývat obrázkem pro Java aplikaci.

▍Vytvoření bitové kopie kontejneru pro aplikaci Java

Víte co a už jste se naučili vše potřebné k vytváření obrázků 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, pak se v něm setkáte pouze se dvěma novými konstrukcemi, které začínají klíčovými slovy ENV и 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. Konkrétně v našem případě umožňuje nastavit URL pro přístup k API aplikace, která provádí analýzu textu.

Klíčové slovo EXPOSE umožňuje sdělit Dockeru, aby otevřel port. Tento port budeme používat při práci s aplikací. Tady to můžete vidět v Dockerfile pro aplikaci SA-Frontend žádný takový příkaz neexistuje. Toto je pouze pro účely dokumentace, jinými slovy, tato konstrukce je pro čtenáře Dockerfile.

Vytvoření obrazu a jeho odeslání do úložiště vypadá přesně jako předchozí příklad. Pokud si ještě nejste příliš jisti svými schopnostmi, odpovídající příkazy naleznete v souboru README.md ve složce sa-webapp.

▍Vytváření obrazu kontejneru pro aplikaci Python

Pokud se podíváte na obsah souboru Dockerfile ve složce sa-logicnic nového tam nenajdete. Příkazy pro sestavení obrazu a jeho odeslání do úložiště by vám také měly být známé, ale stejně jako u ostatních našich aplikací je najdete v souboru README.md ve složce sa-logic.

▍Testování kontejnerizovaných aplikací

Můžete věřit něčemu, co nemáte vyzkoušené? já taky nemůžu. Pojďme otestovat naše nádoby.

1. Spustíme aplikační kontejner sa-logic a nakonfigurujte jej tak, aby naslouchal na portu 5050:

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

2. Spustíme aplikační kontejner sa-webapp a nakonfigurujte jej tak, aby naslouchal na portu 8080. Kromě toho musíme nastavit port, na kterém bude aplikace Python naslouchat požadavkům z aplikace Java, přeřazením proměnné prostředí 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

Informace o tom, jak zjistit IP adresu kontejneru nebo virtuálního počítače Docker, naleznete v souboru README.

Spustíme aplikační kontejner sa-frontend:

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

Nyní je vše připraveno k navigaci v prohlížeči na adresu localhost:80 a otestujte aplikaci.

Vezměte prosím na vědomí, že pokud změníte port pro sa-webapp, nebo pokud používáte virtuální počítač Docker, budete muset soubor upravit App.js ze složky sa-frontendzměnou IP adresy nebo čísla portu v metodě analyzeSentence()nahrazením aktuálních informací namísto zastaralých dat. Poté musíte obrázek znovu sestavit a použít.

Takto nyní vypadá naše aplikační schéma.

Mikroslužby běží v kontejnerech

Shrnutí: proč potřebujeme cluster Kubernetes?

Právě jsme zkontrolovali soubory Dockerfile, hovořil o tom, jak vytvářet obrázky a vkládat je do úložiště Docker. Navíc jsme se naučili, jak urychlit sestavení obrázků pomocí souboru .dockerignore. Výsledkem je, že naše mikroslužby nyní běží v kontejnerech Docker. Zde můžete mít zcela oprávněnou otázku, proč potřebujeme Kubernetes. Odpověď na tuto otázku bude věnována druhé části tohoto materiálu. Mezitím zvažte následující otázku:
Předpokládejme, že naše webová aplikace pro analýzu textu se stala celosvětově populární. Každou minutu k němu přicházejí miliony žádostí. To znamená, že mikroslužby sa-webapp и sa-logic bude ve velkém stresu. Jak škálovat kontejnery s mikroslužbami?

Zdroj: www.habr.com