🥇Tutorial Kubernetes Partea 1: Aplicații, microservicii și containere

La cererea noastră, Habr a creat un hub Kubernetes și ne face plăcere să plasăm prima publicație în ea. Abonati-va!

Kubernetes este ușor. De ce băncile îmi plătesc mulți bani pentru a lucra în acest domeniu, în timp ce oricine poate stăpâni această tehnologie în doar câteva ore?

Dacă vă îndoiți că Kubernetes poate fi învățat atât de repede, vă sugerez să încercați să o faceți singur. Și anume, stăpânind acest material, vei putea rula o aplicație bazată pe microservicii într-un cluster Kubernetes. Pot garanta acest lucru, deoarece în aceeași metodologie pe care o folosesc aici îi învăț clienților noștri cum să lucreze cu Kubernetes. Ce face acest ghid diferit de altele? De fapt, o mulțime de lucruri. Deci, majoritatea acestor materiale încep cu o explicație a lucrurilor simple - conceptele Kubernetes și caracteristicile comenzii kubectl. Autorii acestor articole presupun că cititorul lor este familiarizat cu dezvoltarea de aplicații, microservicii și containerele Docker. Vom merge pe altă cale. Mai întâi, să vorbim despre cum să rulăm o aplicație bazată pe microservicii pe un computer. Apoi ne vom uita la construirea de imagini container pentru fiecare microserviciu. Și după aceea, ne vom familiariza cu Kubernetes și vom analiza implementarea unei aplicații bazate pe microservicii într-un cluster administrat de Kubernetes.

Această abordare, cu o abordare graduală a Kubernetes, va oferi o înțelegere profundă a ceea ce se întâmplă de care are nevoie omul obișnuit pentru a înțelege cât de simplu este totul aranjat în Kubernetes. Kubernetes este cu siguranță o tehnologie simplă, cu condiția ca cine vrea să o stăpânească să știe unde și cum este folosită.

Acum, fără alte prelungiri, să trecem la treabă și să vorbim despre aplicația cu care vom lucra.

Aplicație experimentală

Aplicația noastră va îndeplini o singură funcție. Ia, ca intrare, o propoziție, după care, folosind instrumente de analiză a textului, efectuează o analiză sentimentală a acestei propoziții, obținând o evaluare a atitudinii emoționale a autorului propoziției față de un anumit obiect.

Așa arată fereastra principală a acestei aplicații.

Aplicație web pentru analiza sentimentelor

Din punct de vedere tehnic, aplicația constă din trei microservicii, fiecare dintre ele rezolvă un anumit set de sarcini:

SA-Frontend este un server web Nginx care servește fișiere statice React.
SA-WebApp este o aplicație web scrisă în Java care se ocupă de solicitările de la interfață.
SA-Logic este o aplicație Python care efectuează analiza sentimentelor textului.

Este important de reținut că microserviciile nu există izolat. Ei implementează ideea de „separare a sarcinilor”, dar, în același timp, trebuie să interacționeze între ei.

Fluxurile de date în aplicație

În diagrama de mai sus, puteți vedea etapele numerotate ale sistemului, ilustrând fluxurile de date din aplicație. Să le defalcăm:

Browserul solicită un fișier de la server index.html (care, la rândul său, încarcă pachetul aplicației React).
Utilizatorul interacționează cu aplicația, acest lucru determină un apel către o aplicație web bazată pe Spring.
Aplicația web transmite solicitarea de a analiza textul către aplicația Python.
Aplicația Python analizează sentimentul textului și returnează rezultatul ca răspuns la cerere.
Aplicația Spring trimite un răspuns aplicației React (care, la rândul ei, arată utilizatorului rezultatul textului analizat).

Codul pentru toate aceste aplicații poate fi găsit aici. Vă recomand să copiați acest depozit pentru dvs. chiar acum, deoarece sunt multe experimente interesante cu el înaintea noastră.

Rularea unei aplicații bazată pe microservicii pe mașina locală

Pentru ca aplicația să funcționeze, trebuie să pornim toate cele trei microservicii. Să începem cu cea mai frumoasă dintre ele - aplicația front-end.

▍Înființarea React pentru dezvoltare locală

Pentru a rula o aplicație React, trebuie să instalați framework-ul Node.js și NPM pe computer. După ce instalați toate acestea, mergeți folosind terminalul în folderul proiectului sa-frontend și rulați următoarea comandă:

npm install

Executând această comandă în folder node_modules se vor încărca dependențele aplicației React ale cărei înregistrări se află în fișier package.json. După descărcarea dependențelor în același folder, rulați următoarea comandă:

npm start

Asta e tot. Aplicația React rulează acum și poate fi accesată navigând la adresa browserului localhost:3000. Puteți schimba ceva în codul lui. Veți vedea imediat efectul acestor modificări în browser. Acest lucru este posibil datorită așa-numitei înlocuiri „la cald” a modulelor. Datorită acestui fapt, dezvoltarea front-end se transformă într-o experiență simplă și plăcută.

▍Pregătirea unei aplicații React pentru producție

În scopul utilizării efective a unei aplicații React, trebuie să o transformăm într-un set de fișiere statice și să le oferim clienților folosind un server web.

Pentru a construi aplicația React, folosind din nou terminalul, navigați la dosar sa-frontend și rulați următoarea comandă:

npm run build

Aceasta va crea un director în folderul proiectului build. Acesta va conține toate fișierele statice necesare pentru ca aplicația React să funcționeze.

▍Servirea de fișiere statice cu Nginx

Mai întâi trebuie să instalați și să rulați serverul web Nginx. Aici îl puteți descărca și găsi instrucțiuni pentru instalarea și rularea acestuia. Apoi trebuie să copiați conținutul folderului sa-frontend/build în dosar [your_nginx_installation_dir]/html.

Cu această abordare, fișierul generat în timpul asamblarii aplicației React index.html va fi disponibil la [your_nginx_installation_dir]/html/index.html. Acesta este fișierul pe care, implicit, serverul Nginx îl emite atunci când îl accesează. Serverul este configurat să asculte pe un port 80, dar îl puteți personaliza așa cum doriți, editând fișierul [your_nginx_installation_dir]/conf/nginx.conf.

Acum deschideți browserul și accesați localhost:80. Veți vedea pagina aplicației React.

Aplicația React deservită de serverul Nginx

Dacă acum introduceți ceva în câmp Type your sentence și apăsați butonul Send - nu se va întâmpla nimic. Dar, dacă te uiți la consolă, poți vedea mesaje de eroare acolo. Pentru a înțelege exact unde apar aceste erori, să analizăm codul aplicației.

▍Analiza codului aplicației front-end

Privind codul fișierului App.js, putem vedea că făcând clic pe butonul Send apelează la o metodă analyzeSentence(). Codul acestei metode este prezentat mai jos. În același timp, acordați atenție faptului că pentru fiecare rând la care există un comentariu al formularului # Номер, există o explicație dată sub cod. În același mod, vom analiza și alte fragmente de cod.

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 la care se face cererea POST. Se presupune că această adresă este o aplicație care așteaptă astfel de solicitări.

2.Organismul de solicitare a trimis la cerere. Iată un exemplu de corp de solicitare:

{
    sentence: "I like yogobella!"
}

3.Când se primește un răspuns la o solicitare, starea componentei este actualizată. Acest lucru face ca componenta să fie redată din nou. Dacă primim date (adică un obiect JSON care conține datele introduse și scorul de text calculat), vom scoate componenta Polarityatâta timp cât sunt îndeplinite condiţiile. Iată cum descriem componenta:

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

Codul pare să funcționeze destul de bine. Ce e în neregulă aici, oricum? Dacă presupuneți că la adresa la care aplicația încearcă să trimită o cerere POST, nu există încă nimic care să poată accepta și procesa această solicitare, atunci veți avea perfectă dreptate. Si anume, sa proceseze cererile care vin la adresa http://localhost:8080/sentiment, trebuie să rulăm o aplicație web bazată pe Spring.

Avem nevoie de o aplicație Spring care poate accepta o solicitare POST

▍Configurarea unei aplicații web bazată pe Spring

Pentru a implementa o aplicație Spring, aveți nevoie de JDK8 și Maven și de variabile de mediu configurate corespunzător. După ce instalați toate acestea, puteți continua să lucrați la proiectul nostru.

▍Ambalarea aplicației într-un fișier jar

Navigați, folosind terminalul, la folder sa-webapp și introduceți următoarea comandă:

mvn install

După executarea acestei comenzi în folder sa-webapp directorul va fi creat target. Aici va fi localizată aplicația Java, ambalată într-un fișier jar, reprezentat de fișier sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Lansarea unei aplicații Java

Accesați folderul target și rulați aplicația cu următoarea comandă:

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

Va apărea o eroare la executarea acestei comenzi. Pentru a începe să o reparăm, putem analiza detaliile excepției din datele de urmărire a stivei:

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

Pentru noi, cel mai important lucru aici este menționarea imposibilității de a clarifica sensul sa.logic.api.url. Să analizăm codul unde apare eroarea.

▍Analiza codului aplicației Java

Iată fragmentul de cod în care apare eroarea.

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

În SentimentController există un câmp saLogicApiUrl. Valoarea acestuia este stabilită de proprietate sa.logic.api.url.
rând saLogicApiUrl se concatenează cu valoarea /analyse/sentiment. Împreună formează o adresă pentru efectuarea unui apel către microserviciul care efectuează analiza textului.

▍Setarea unei valori de proprietate

În primăvară, sursa implicită a valorilor proprietăților este un fișier application.properties, care poate fi găsit la sa-webapp/src/main/resources. Dar utilizarea acestuia nu este singura modalitate de a seta valorile proprietăților. Puteți face acest lucru și cu următoarea comandă:

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

Valoarea acestei proprietăți ar trebui să indice adresa aplicației noastre Python.

Prin configurarea acestuia, îi spunem aplicației web Spring unde trebuie să meargă pentru a executa cererile de analiză a textului.

Pentru a nu ne complica viața, vom decide că aplicația Python va fi disponibilă la localhost:5000 și încearcă să nu uiți de asta. Ca rezultat, comanda de pornire a aplicației Spring va arăta astfel:

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

Sistemului nostru lipsește o aplicație Python

Acum trebuie doar să rulăm aplicația Python și sistemul va funcționa conform așteptărilor.

▍Configurarea unei aplicații Python

Pentru a rula o aplicație Python, trebuie să aveți instalate Python 3 și Pip și trebuie să aveți setate corect variabilele de mediu corespunzătoare.

▍Instalați dependențe

Accesați folderul proiect sa-logic/sa și rulați următoarele comenzi:

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

▍Lansarea aplicației

Cu dependențele instalate, suntem gata să rulăm aplicația:

python sentiment_analysis.py

După executarea acestei comenzi, ni se va spune următoarele:

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

Aceasta înseamnă că aplicația rulează și așteaptă solicitări la localhost:5000/

▍Cercetarea codului

Să ne uităm la codul aplicației Python pentru a înțelege cum răspunde la solicitări:

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

Inițializarea obiectului Flask.
Specificarea adresei pentru a-i face cereri POST.
Recuperarea unei proprietăți sentence din organul de cerere.
Inițializarea obiectului anonim TextBlob și obținerea valorii polarity pentru prima propunere primită în corpul cererii (în cazul nostru, aceasta este singura propunere depusă spre analiză).
Returnarea unui răspuns, al cărui corp conține textul ofertei și indicatorul calculat pentru aceasta polarity.
Lansarea aplicației Flask, care va fi disponibilă la 0.0.0.0:5000 (de asemenea, îl puteți accesa folosind o construcție a formularului localhost:5000).

Acum rulează microservicii care alcătuiesc aplicația. Sunt setate să interacționeze între ei. Iată cum arată diagrama aplicației în această etapă de lucru.

Toate microserviciile care compun aplicația sunt aduse într-o stare sănătoasă

Acum, înainte de a continua, deschideți aplicația React într-un browser și încercați să analizați o propoziție cu ea. Dacă totul este făcut corect - după apăsarea butonului Send veți vedea rezultatele analizei sub caseta de text.

În secțiunea următoare, vom vorbi despre cum să rulăm microserviciile noastre în containerele Docker. Acest lucru este necesar pentru a pregăti aplicația să ruleze în clusterul Kubernetes.

Containere Docker

Kubernetes este un sistem pentru automatizarea implementării, scalarea și gestionarea aplicațiilor containerizate. Se mai numește și „orchestrator de containere”. Dacă Kubernetes lucrează cu containere, atunci înainte de a folosi acest sistem, trebuie mai întâi să achiziționăm aceste containere. Dar mai întâi, să vorbim despre ce sunt containerele. Poate cel mai bun răspuns la întrebarea despre ce este acesta poate fi găsit documentație către Docker:

O imagine container este un pachet ușor, autonom, executabil, care conține o aplicație, care include tot ceea ce este necesar pentru a o rula: codul aplicației, mediul de rulare, instrumente și biblioteci de sistem, setări. Programele containerizate pot fi utilizate atât în mediile Linux, cât și în Windows și vor funcționa întotdeauna la fel, indiferent de infrastructură.

Aceasta înseamnă că containerele pot fi rulate pe orice computer, inclusiv pe serverele de producție și, în orice mediu, aplicațiile incluse în ele vor funcționa în același mod.

Pentru a explora caracteristicile containerelor și a le compara cu alte moduri de a rula aplicații, să ne uităm la exemplul de servire a unei aplicații React folosind o mașină virtuală și un container.

▍Servirea de fișiere statice ale unei aplicații React folosind o mașină virtuală

Încercând să organizăm întreținerea fișierelor statice folosind mașini virtuale, vom întâlni următoarele dezavantaje:

Utilizarea ineficientă a resurselor, deoarece fiecare mașină virtuală este un sistem de operare complet.
Dependența de platformă. Ceea ce funcționează pe un computer local poate să nu funcționeze pe un server de producție.
Scalare lentă și consumatoare de resurse a unei soluții de mașină virtuală.

Serverul web Nginx care servește fișiere statice care rulează într-o mașină virtuală

Dacă containerele sunt folosite pentru a rezolva o problemă similară, atunci, în comparație cu mașinile virtuale, pot fi remarcate următoarele puncte forte:

Utilizarea eficientă a resurselor: lucrați cu sistemul de operare folosind Docker.
Independenta platformei. Un container pe care un dezvoltator îl poate rula pe propriul computer va rula oriunde.
Implementare ușoară prin utilizarea straturilor de imagine.

Serverul web Nginx care servește fișiere statice care rulează într-un container

Am comparat doar mașinile virtuale și containerele în câteva puncte, dar chiar și asta este suficient pentru a înțelege punctele forte ale containerelor. Aici Puteți găsi detalii despre containerele Docker.

▍Crearea unei imagini de container pentru o aplicație React

Elementul de bază al unui container Docker este fișierul Dockerfile. La începutul acestui fișier, este înregistrată o imagine de bază a containerului, apoi este inclusă o secvență de instrucțiuni care indică modul de creare a unui container care va satisface nevoile unei aplicații.

Înainte de a începe să lucrăm cu fișierul Dockerfile, amintiți-vă ce am făcut pentru a pregăti fișierele aplicației React pentru încărcare pe serverul Nginx:

Construirea unui pachet de aplicație React (npm run build).
Pornirea serverului Nginx.
Copierea conținutului unui director build din folderul de proiect sa-frontend în folderul serverului nginx/html.

Mai jos puteți vedea paralelele dintre crearea unui container și acțiunile de mai sus efectuate pe computerul local.

▍Pregătirea unui fișier Docker pentru aplicația SA-Frontend

Instrucțiuni care trebuie incluse în Dockerfile pentru aplicare SA-Frontend, constau doar din două comenzi. Cert este că echipa de dezvoltare Nginx a pregătit o bază imagine pentru Nginx, pe care îl vom folosi pentru a ne construi imaginea. Iată cei doi pași pe care trebuie să îi descriem:

Trebuie să faceți din imaginea Nginx baza imaginii.
Conținutul folderului sa-frontend/build trebuie să copiați în folderul de imagini nginx/html.

Dacă trecem de la această descriere la fișier Dockerfile, atunci va arăta astfel:

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

După cum puteți vedea, totul aici este foarte simplu, în timp ce conținutul fișierului se dovedește chiar destul de lizibil și de înțeles. Acest fișier îi spune sistemului să ia imaginea nginx cu tot ce are deja și copiați conținutul directorului build la director nginx/html.

Aici este posibil să aveți o întrebare despre cum știu exact unde să copiez fișierele din folder build, adică de unde a venit calea /usr/share/nginx/html. De fapt, nici aici nu este nimic complicat. Cert este că informațiile relevante pot fi găsite în Descriere imagine.

▍Asamblarea imaginii și încărcarea acesteia în depozit

Înainte de a putea lucra cu o imagine finalizată, trebuie să o trimitem la depozitul de imagini. Pentru a face acest lucru, vom folosi platforma gratuită de găzduire a imaginilor bazată pe cloud Docker Hub. În această etapă de lucru, trebuie să faceți următoarele:

Instalare Docher.
Înregistrați-vă pe site-ul Docker Hub.
Conectați-vă la contul dvs. executând următoarea comandă în terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Acum trebuie, folosind terminalul, să mergeți la director sa-frontend și rulați următoarea comandă acolo:

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

Aici și mai jos în comenzi similare $DOCKER_USER_ID ar trebui înlocuit cu numele dvs. de utilizator pe Docker Hub. De exemplu, această parte a comenzii ar putea arăta astfel: rinormaloku/sentiment-analysis-frontend.

În acest caz, această comandă poate fi scurtată prin eliminarea din ea -f Dockerfile, deoarece folderul în care executăm această comandă are deja acest fișier.

Pentru a trimite imaginea finalizată în depozit, avem nevoie de următoarea comandă:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

După ce o finalizați, verificați lista de depozite pe Docker Hub pentru a vedea dacă imaginea a fost trimisă cu succes în stocarea în cloud.

▍Pornirea unui container

Acum oricine poate descărca și rula imaginea cunoscută ca $DOCKER_USER_ID/sentiment-analysis-frontend. Pentru a face acest lucru, trebuie să rulați următoarea secvență de comenzi:

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

Acum containerul rulează și putem continua să lucrăm creând alte imagini de care avem nevoie. Dar înainte de a continua, să înțelegem designul 80:80, care se găsește în comanda pentru a rula imaginea și poate părea confuz.

Primul număr 80 este numărul portului gazdei (adică computerul local).
Al doilea număr 80 este portul containerului către care trebuie redirecționată cererea.

Luați în considerare următoarea ilustrație.

Port forwarding

Sistemul transmite cererile din port <hostPort> spre port <containerPort>. Adică accesarea portului 80 computerul este redirecționat către un port 80 recipient.

Din portul 80 deschis pe computerul local, puteți accesa aplicația de pe acest computer la localhost:80. Dacă sistemul dumneavoastră nu acceptă Docker, puteți rula aplicația pe o mașină virtuală Docker, a cărei adresă va arăta ca <docker-machine ip>:80. Pentru a afla adresa IP a mașinii virtuale Docker, puteți utiliza comanda docker-machine ip.

În acest moment, odată ce containerul aplicației front-end a fost lansat cu succes, ar trebui să puteți deschide pagina sa într-un browser.

▍.dockerignore fișier

Construirea imaginii aplicației SA-Frontend, am putut observa că acest proces este extrem de lent. Acest lucru se datorează faptului că contextul de construire a imaginii trebuie trimis la demonul Docker. Directorul care reprezintă contextul de construire este dat ca ultimul argument al comenzii docker build. În cazul nostru, există un punct la sfârșitul acestei comenzi. Acest lucru duce la includerea următoarei structuri în contextul de asamblare:

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

Dar dintre toate folderele prezente aici, avem nevoie doar de un folder build. A descărca orice altceva este o pierdere de timp. Puteți accelera construirea spunându-i lui Docker ce directoare să ignore. Pentru a face acest lucru, avem nevoie de un fișier .dockerignore. Tu, dacă ești familiarizat cu fișierul .gitignore, structura acestui fișier va părea probabil familiară. Listează directoare pe care sistemul de creare a imaginii le poate ignora. În cazul nostru, conținutul acestui fișier arată astfel:

node_modules
src
public

fișier .dockerignore trebuie să fie în același folder cu fișierul Dockerfile. Acum asamblarea imaginii va dura câteva secunde.

Să ne ocupăm acum de imaginea pentru o aplicație Java.

▍Crearea unei imagini container pentru o aplicație Java

Știți ce și ați învățat deja tot ce aveți nevoie pentru a crea imagini container. De aceea, această secțiune va fi foarte scurtă.

Deschideți fișierul Dockerfile, care se află în folderul proiectului sa-webapp. Dacă citiți textul acestui fișier, atunci în el veți întâlni doar două construcții noi care încep cu cuvinte cheie ENV и EXPOSE:

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

Cuvânt cheie ENV vă permite să declarați variabile de mediu în interiorul containerelor Docker. În special, în cazul nostru, vă permite să setați o adresă URL pentru a accesa API-ul aplicației care efectuează analiza textului.

Cuvânt cheie EXPOSE vă permite să spuneți lui Docker să deschidă un port. Vom folosi acest port în timp ce lucrăm cu aplicația. Aici puteți vedea asta în Dockerfile pentru aplicare SA-Frontend nu există o astfel de comandă. Acest lucru este doar în scopuri de documentare, cu alte cuvinte, acest construct este pentru cititor Dockerfile.

Construirea imaginii și împingerea acesteia în depozit arată exact ca exemplul anterior. Dacă nu ești încă foarte încrezător în abilitățile tale, comenzile corespunzătoare pot fi găsite în fișier README.md în dosar sa-webapp.

▍Crearea unei imagini container pentru o aplicație Python

Dacă aruncați o privire la conținutul fișierului Dockerfile în dosar sa-logicnu vei găsi nimic nou acolo. Comenzile pentru construirea imaginii și împingerea acesteia în depozit ar trebui să vă fie deja familiare, dar, ca și în cazul celorlalte aplicații ale noastre, ele pot fi găsite în fișier README.md în dosar sa-logic.

▍Testarea aplicațiilor containerizate

Poți avea încredere în ceva ce nu ai testat? nu pot nici eu. Să ne testăm containerele.

Să începem containerul aplicației sa-logic și configurați-l pentru a asculta pe un port 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Să începem containerul aplicației sa-webapp și configurați-l pentru a asculta pe un port 8080. În plus, trebuie să setăm portul pe care aplicația Python va asculta cererile din aplicația Java prin reatribuirea variabilei de mediu 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
```

Pentru a afla cum să aflați adresa IP a unui container sau a unui VM Docker, consultați fișierul README.

Să începem containerul aplicației sa-frontend:

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

Acum totul este gata pentru a naviga în browser la adresa localhost:80 și testați aplicația.

Vă rugăm să rețineți că dacă schimbați portul pentru sa-webapp, sau dacă rulați o VM Docker, va trebui să editați fișierul App.js din dosar sa-frontendprin schimbarea adresei IP sau a numărului portului din metodă analyzeSentence()prin înlocuirea informațiilor actuale în locul datelor învechite. După aceea, trebuie să reasamblați imaginea și să o utilizați.

Așa arată acum diagrama aplicației noastre.

Microservicii rulează în containere

Rezumat: de ce avem nevoie de un cluster Kubernetes?

Tocmai am analizat dosarele Dockerfile, a vorbit despre cum să construiți imagini și să le împingeți într-un depozit Docker. În plus, am învățat cum să grăbim asamblarea imaginilor folosind fișierul .dockerignore. Drept urmare, microserviciile noastre rulează acum în containerele Docker. Aici este posibil să aveți o întrebare complet justificată despre motivul pentru care avem nevoie de Kubernetes. Răspunsul la această întrebare va fi dedicat celei de-a doua părți a acestui material. Între timp, luați în considerare următoarea întrebare:
Să presupunem că aplicația noastră web de analiză de text a devenit populară în întreaga lume. Milioane de cereri îi vin în fiecare minut. Aceasta înseamnă că microservicii sa-webapp и sa-logic va fi supus unui stres enorm. Cum să scalați containerele care rulează microservicii?

Sursa: www.habr.com

Tutorial Kubernetes Partea 1: Aplicații, microservicii și containere