🥇Kubernetes Tutorial Diel 1: Applikaasjes, mikrotsjinsten en konteners

Op ús fersyk makke Habr in hub Kubernetes en wy binne bliid om de earste publikaasje yn te pleatsen. Ynskriuwe!

Kubernetes is maklik. Wêrom betelje banken my in soad jild om yn dit gebiet te wurkjen, wylst elkenien dizze technology yn mar in pear oeren behearskje kin?

As jo twifelje dat Kubernetes sa fluch leard wurde kin, stel ik foar dat jo besykje it sels te dwaan. Jo kinne nammentlik dit materiaal behearskje, in applikaasje kinne útfiere basearre op mikrotsjinsten yn in Kubernetes-kluster. Ik kin dit garandearje, om't it yn deselde metodyk is dy't ik hjir brûke dat ik ús kliïnten lear hoe't se mei Kubernetes wurkje. Wat makket dizze gids oars as oaren? Eins, in protte dingen. Dat, de measte fan dizze materialen begjinne mei in ferklearring fan ienfâldige dingen - de begripen fan Kubernetes en de funksjes fan it kommando kubectl. De skriuwers fan dizze artikels geane derfan út dat har lêzer bekend is mei applikaasjeûntwikkeling, mikrotsjinsten en Docker-konteners. Wy geane de oare kant út. Litte wy earst prate oer hoe't jo in applikaasje kinne útfiere basearre op mikrotsjinsten op in kompjûter. Dan sille wy sjen nei it bouwen fan kontenerôfbyldings foar elke mikrotsjinst. En dêrnei sille wy yn 'e kunde komme mei Kubernetes en analysearje de ynset fan in applikaasje basearre op mikrotsjinsten yn in kluster beheard troch Kubernetes.

Dizze oanpak, mei in stadige oanpak fan Kubernetes, sil de djipte fan begryp jaan fan wat der bart dat de gemiddelde persoan nedich is om te begripen hoe gewoan alles yn Kubernetes is regele. Kubernetes is grif in ienfâldige technology, op betingst dat wa't it behearskje wol wit wêr't en hoe't it brûkt wurdt.

No, sûnder fierdere ado, litte wy oan it wurk gean en prate oer de applikaasje wêrmei wy sille wurkje.

Eksperimintele app

Us applikaasje sil mar ien funksje útfiere. It nimt, as ynfier, ien sin, wêrnei't it, mei help fan tekstanalyze-ark, in sentimintanalyze fan dizze sin útfiert, in beoardieling fan 'e emosjonele hâlding fan' e skriuwer fan 'e sin ta in bepaald objekt.

Dit is hoe't it haadfinster fan dizze applikaasje derút sjocht.

Sentiment Analysis Web Application

Fanút in technysk eachpunt bestiet de applikaasje út trije mikrotsjinsten, dy't elk in bepaalde set fan taken oplost:

SA-Frontend is in Nginx-webserver dy't statyske React-bestannen tsjinnet.
SA-WebApp is in webapplikaasje skreaun yn Java dy't fersiken fan 'e frontend behannelet.
SA-Logic is in Python-applikaasje dy't analyse fan tekstsentimint útfiert.

It is wichtich om te notearjen dat mikrotsjinsten net yn isolaasje besteane. Se implementearje it idee fan "skieding fan taken", mar se moatte tagelyk mei-inoar omgean.

Gegevensstreamen yn 'e applikaasje

Yn it boppesteande diagram kinne jo de nûmere stadia fan it systeem sjen, de gegevensstreamen yn 'e applikaasje yllustrearje. Litte wy se brekke:

De browser freget in bestân fan de tsjinner index.html (wat op syn beurt it React-apppakket laadt).
De brûker ynteraksje mei de applikaasje, dit soarget foar in oprop nei in webapplikaasje basearre op Spring.
De webapplikaasje stjoert it fersyk om de tekst te parsearjen troch nei de Python-applikaasje.
De Python-applikaasje analysearret it sentimint fan 'e tekst en jout it resultaat werom as antwurd op it fersyk.
De Spring-applikaasje stjoert in antwurd nei de React-applikaasje (dy't op syn beurt it resultaat fan 'e parsearde tekst oan 'e brûker toant).

De koade foar al dizze applikaasjes is te finen hjir. Ik advisearje dat jo dit repository no direkt nei josels kopiearje, om't d'r in protte nijsgjirrige eksperiminten mei foar ús binne.

In applikaasje útfiere basearre op mikrotsjinsten op 'e lokale masine

Om de applikaasje te wurkjen, moatte wy alle trije mikrotsjinsten begjinne. Litte wy begjinne mei de moaiste fan har - de front-end-applikaasje.

▍React ynstelle foar lokale ûntwikkeling

Om in React-applikaasje út te fieren, moatte jo it Node.js-ramt en NPM op jo kompjûter ynstallearje. Nei it ynstallearjen fan dit alles, gean mei de terminal nei de projektmap sa-frontend en fier it folgjende kommando út:

npm install

Troch dit kommando út te fieren yn 'e map node_modules de ôfhinklikens fan 'e React-applikaasje sille wurde laden, wêrfan de records yn it bestân binne package.json. Nei it downloaden fan de ôfhinklikens yn deselde map, fier it folgjende kommando út:

npm start

Da's alles. De React-app rint no en kin tagonklik wurde troch te navigearjen nei it browseradres localhost:3000. Jo kinne wat feroarje yn syn koade. Jo sille fuortendaliks it effekt fan dizze wizigingen yn 'e browser sjen. Dit is mooglik troch de saneamde "hot" ferfanging fan modules. Hjirmei feroaret front-end ûntwikkeling yn in ienfâldige en noflike ûnderfining.

▍ In React-app tariede foar produksje

Foar it feitlik gebrûk fan in React-app moatte wy it konvertearje yn in set statyske bestannen en se tsjinje oan kliïnten mei in webserver.

Om de React-app te bouwen, opnij mei de terminal, navigearje nei de map sa-frontend en fier it folgjende kommando út:

npm run build

Dit sil in map meitsje yn 'e projektmap build. It sil alle statyske bestannen befetsje dy't nedich binne foar de React-applikaasje om te wurkjen.

▍ Statyske bestannen tsjinje mei Nginx

Earst moatte jo de Nginx-webserver ynstallearje en útfiere. it is jo kinne it downloade en ynstruksjes fine foar it ynstallearjen en útfieren. Dan moatte jo de ynhâld fan 'e map kopiearje sa-frontend/build oan map [your_nginx_installation_dir]/html.

Mei dizze oanpak wurdt it bestân generearre tidens de gearstalling fan 'e React-applikaasje index.html sil beskikber wêze by [your_nginx_installation_dir]/html/index.html. Dit is it bestân dat, standert, de Nginx-tsjinner problemen by it tagong ta it. De tsjinner is ynsteld om te harkjen op in poarte 80, mar jo kinne it oanpasse lykas jo wolle troch it bestân te bewurkjen [your_nginx_installation_dir]/conf/nginx.conf.

Iepenje no jo browser en gean nei localhost:80. Jo sille de React app-pagina sjen.

React app tsjinne troch Nginx-tsjinner

As jo no wat yn it fjild ynfiere Type your sentence en druk op de knop Send - der sil neat barre. Mar, as jo nei de konsole sjogge, kinne jo dêr flaterberjochten sjen. Om krekt te begripen wêr't dizze flaters foarkomme, litte wy de applikaasjekoade analysearje.

▍Analyse fan 'e koade fan' e front-end-applikaasje

Sjoch nei de koade fan it bestân App.js, kinne wy sjen dat te klikken op de knop Send neamt in metoade analyzeSentence(). De koade foar dizze metoade wurdt hjirûnder werjûn. Tagelyk betelje omtinken oan it feit dat foar elke rigel dêr't in kommentaar fan it formulier is # Номер, der is in útlis jûn ûnder de koade. Op deselde wize sille wy oare koadefragminten parse.

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. De URL wêrop it POST-fersyk wurdt makke. Der wurdt fan útgien dat dit adres in applikaasje is dy't wachtet op sokke oanfragen.

2.It fersyk lichem stjoerd nei de oanfraach. Hjir is in foarbyldfersyklichem:

{
    sentence: "I like yogobella!"
}

3.As in antwurd op in fersyk wurdt ûntfongen, wurdt de steat fan 'e komponint bywurke. Dit soarget foar it komponint om opnij te meitsjen. As wy gegevens ûntfange (dat is in JSON-objekt dat de ynfierde gegevens en de berekkene tekstskoare befettet), sille wy de komponint útfiere Polaritysa lang as oan de betingsten foldien wurdt. Hjir is hoe't wy de komponint beskriuwe:

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

De koade liket frij goed te wurkjen. Wat is hjir dochs mis? As jo oannimme dat op it adres wêrnei't de applikaasje besiket in POST-fersyk te stjoeren, d'r noch neat is dat dit fersyk akseptearje en ferwurkje kin, dan sille jo absolút gelyk hawwe. Nammentlik om fersiken te ferwurkjen dy't op it adres komme http://localhost:8080/sentiment, wy moatte in webapplikaasje útfiere basearre op Spring.

Wy hawwe in Spring-applikaasje nedich dy't in POST-fersyk kin akseptearje

▍In webapplikaasje ynstelle basearre op Spring

Om in Spring-applikaasje yn te setten, hawwe jo JDK8 en Maven en goed ynstelde omjouwingsfariabelen nedich. Nei it ynstallearjen fan dit alles, kinne jo trochgean mei wurkjen oan ús projekt.

▍De applikaasje ynpakke yn in jar-bestân

Navigearje, mei de terminal, nei de map sa-webapp en fier it folgjende kommando yn:

mvn install

Nei it útfieren fan dit kommando yn 'e map sa-webapp map sil oanmakke wurde target. Dit is wêr't de Java-applikaasje sil lizze, ferpakt yn in jar-bestân, fertsjintwurdige troch it bestân sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ In Java-applikaasje starte

Gean nei map target en útfiere de applikaasje mei it folgjende kommando:

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

Der sil in flater foarkomme by it útfieren fan dit kommando. Om it te begjinnen te reparearjen, kinne wy de útsûnderingsdetails yn 'e stack trace gegevens parse:

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

Foar ús is it wichtichste ding hjir de fermelding fan 'e ûnmooglikheid om de betsjutting te ferdúdlikjen sa.logic.api.url. Litte wy de koade analysearje wêr't de flater foarkomt.

▍ Analyze fan Java-applikaasjekoade

Hjir is it koadefragment wêr't de flater foarkomt.

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

Yn SentimentController der is in fjild saLogicApiUrl. De wearde dêrfan wurdt ynsteld troch it pân sa.logic.api.url.
String saLogicApiUrl gearhinget mei wearde /analyse/sentiment. Tegearre foarmje se in adres foar it meitsjen fan in oprop nei de mikrotsjinst dy't tekstanalyze docht.

▍ It ynstellen fan in eigendomswearde

Yn 'e maitiid is de standertboarne fan eigendomswearden in bestân application.properties, dat is te finen op sa-webapp/src/main/resources. Mar it brûken is net de ienige manier om eigendomswearden yn te stellen. Jo kinne dit ek dwaan mei it folgjende kommando:

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

De wearde fan dit pân moat ferwize nei it adres fan ús Python-applikaasje.

Troch it te konfigurearjen, fertelle wy de Spring-webapplikaasje wêr't it moat gean om oanfragen foar tekstparsing te meitsjen.

Om ús libben net te komplisearjen, sille wy beslute dat de Python-applikaasje beskikber sil wêze by localhost:5000 en besykje it net te ferjitten. As resultaat sil it kommando om de Spring-applikaasje te begjinnen sa útsjen:

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

Us systeem mist in Python-applikaasje

No moatte wy gewoan de Python-applikaasje útfiere en it systeem sil wurkje lykas ferwachte.

▍In Python-applikaasje ynstelle

Om in Python-applikaasje út te fieren, moatte jo Python 3 en Pip hawwe ynstalleare, en jo moatte de passende omjouwingsfariabelen goed ynsteld hawwe.

▍ Ynstallearje ôfhinklikens

Gean nei projekt map sa-logic/sa en fier de folgjende kommando's út:

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

▍App starte

Mei de ôfhinklikens ynstalleare, binne wy ree om de applikaasje út te fieren:

python sentiment_analysis.py

Nei it útfieren fan dit kommando sille wy it folgjende wurde ferteld:

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

Dit betsjut dat de applikaasje rint en wachtet op oanfragen by localhost:5000/

▍ Koadeûndersyk

Litte wy nei de Python-applikaasjekoade sjen om te begripen hoe't it reagearret op oanfragen:

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

Objekt inisjalisaasje Flask.
It adres opjaan foar it meitsjen fan POST-oanfragen dêroan.
It opheljen fan in eigendom sentence út it fersyk lichem.
Anonyme foarwerp inisjalisaasje TextBlob en it krijen fan de wearde polarity foar it earste foarstel ûntfongen yn it lichem fan it fersyk (yn ús gefal is dit it ienige foarstel dat foar analyse yntsjinne is).
It weromjaan fan in antwurd, wêrfan it lichem de tekst fan it oanbod befettet en de dêrfoar berekkene yndikator polarity.
It starten fan de Flask-applikaasje, dy't beskikber sil wêze by 0.0.0.0:5000 (jo kinne ek tagong krije mei in konstruksje fan it formulier localhost:5000).

No rinne de mikrotsjinsten dy't de applikaasje foarmje. Se binne ynsteld om ynteraksje mei elkoar. Hjir is hoe't it applikaasjediagram der útsjocht op dit faze fan wurk.

Alle mikrotsjinsten dy't de applikaasje útmeitsje, wurde yn in sûne steat brocht

No, foardat wy trochgean, iepenje de React-app yn in browser en besykje wat sin mei te parsearjen. As alles is dien goed - nei it drukken op de knop Send jo sille de analyseresultaten ûnder it tekstfak sjen.

Yn 'e folgjende seksje sille wy prate oer hoe't jo ús mikrotsjinsten kinne útfiere yn Docker-konteners. Dit is nedich om de applikaasje ta te rieden om te rinnen yn it Kubernetes-kluster.

Docker konteners

Kubernetes is in systeem foar it automatisearjen fan de ynset, skaalfergrutting en behear fan containerized applikaasjes. It wurdt ek wol in "containerorkestrator" neamd. As Kubernetes wurket mei konteners, dan moatte wy dizze konteners earst krije foardat jo dit systeem brûke. Mar earst litte wy prate oer wat konteners binne. Miskien is it bêste antwurd op 'e fraach wat it is te finen yn dokumintaasje oan Docker:

In kontenerôfbylding is in lichtgewicht, selsstannich, útfierber pakket dat in applikaasje befettet, dy't alles omfettet dat nedich is om it út te fieren: applikaasjekoade, runtime-omjouwing, systeemark en bibleteken, ynstellings. Containerisearre programma's kinne brûkt wurde yn sawol Linux- as Windows-omjouwings en sille altyd itselde wurkje, nettsjinsteande de ynfrastruktuer.

Dit betsjut dat konteners kinne wurde útfierd op elke kompjûter, ynklusyf produksjeservers, en yn elke omjouwing sille de applikaasjes dy't se befetsje op deselde manier wurkje.

Om de funksjes fan konteners te ferkennen en se te fergelykjen mei oare manieren om applikaasjes út te fieren, litte wy nei it foarbyld sjen fan it tsjinjen fan in React-applikaasje mei in firtuele masine en in kontener.

▍ Statyske bestannen tsjinje fan in React-applikaasje mei in firtuele masine

Besykje te organisearjen it ûnderhâld fan statyske bestannen mei firtuele masines, sille wy de folgjende neidielen tsjinkomme:

Net effisjint gebrûk fan boarnen, om't elke firtuele masine in folslein bestjoeringssysteem is.
Platfoarm ôfhinklikens. Wat wurket op guon lokale kompjûter kin goed net wurkje op in produksje tsjinner.
Stadich en boarne-yntinsive skaalfergrutting fan in oplossing foar firtuele masines.

Nginx-webserver tsjinnet statyske bestannen dy't rinne yn in firtuele masine

As konteners wurde brûkt om in ferlykber probleem op te lossen, dan kinne, yn ferliking mei firtuele masines, de folgjende sterke punten wurde opmurken:

Effisjint gebrûk fan boarnen: wurkje mei it bestjoeringssysteem mei Docker.
Platfoarm ûnôfhinklikens. In kontener dy't in ûntwikkelder op har eigen kompjûter útfiere kin, sil oeral rinne.
Lichtgewicht ynset troch it brûken fan byldlagen.

Nginx-webserver tsjinnet statyske bestannen dy't rinne yn in kontener

Wy hawwe allinich firtuele masines en konteners op in pear punten fergelike, mar sels dat is genôch om in gefoel te krijen foar de sterke punten fan konteners. it is Jo kinne details fine oer Docker-konteners.

▍ In kontenerôfbylding bouwe foar in React-app

It basisboublok fan in Docker-kontener is it bestân Dockerfile. Oan it begjin fan dit bestân wurdt in basisôfbylding fan 'e kontener opnommen, dan is in folchoarder fan ynstruksjes opnommen dy't oanjout hoe't jo in kontener meitsje kinne dy't oan 'e behoeften fan in applikaasje foldocht.

Foardat wy begjinne te wurkjen mei de triem Dockerfile, tink oan wat wy dien hawwe om de bestannen fan 'e React-applikaasje foar te meitsjen foar it uploaden nei de Nginx-tsjinner:

Bouwe in React-apppakket (npm run build).
Begjin de Nginx-tsjinner.
It kopiearjen fan de ynhâld fan in map build út projekt map sa-frontend nei de tsjinner map nginx/html.

Hjirûnder kinne jo de parallellen sjen tusken it meitsjen fan in kontener en de boppesteande aksjes útfierd op 'e lokale kompjûter.

▍ In Dockerfile tariede foar de SA-Frontend-applikaasje

Ynstruksjes om yn te nimmen Dockerfile foar tapassing SA-Frontend, besteane út mar twa kommando's. It feit is dat it Nginx-ûntwikkelteam in basis hat taret in byld foar Nginx, dy't wy sille brûke om ús ôfbylding te bouwen. Hjir binne de twa stappen dy't wy moatte beskriuwe:

Jo moatte it Nginx-ôfbylding de basis fan it byld meitsje.
Folder ynhâld sa-frontend/build moatte kopiearje nei de ôfbylding map nginx/html.

As wy gean fan dizze beskriuwing nei de triem Dockerfile, dan sil it der sa útsjen:

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

Sa't jo sjen kinne, is alles hjir heul ienfâldich, wylst de ynhâld fan 'e bestân sels frij lêsber en begryplik blykt te wêzen. Dizze triem fertelt it systeem om de ôfbylding te nimmen nginx mei alles wat it al hat, en kopiearje de ynhâld fan 'e map build nei de map nginx/html.

Hjir kinne jo in fraach hawwe oer hoe't ik wit wêr't jo de bestannen út 'e map krekt moatte kopiearje build, dus wêr kaam it paad wei /usr/share/nginx/html. Yn feite is hjir ek neat yngewikkeld. It feit is dat de relevante ynformaasje te finen is yn beskriuwing byld.

▍ De ôfbylding gearstalle en it uploaden nei de repository

Foardat wy mei in foltôge ôfbylding kinne wurkje, moatte wy it yntsjinje by it byldbewarplak. Om dit te dwaan, sille wy it fergese cloud-basearre byldhostingplatfoarm Docker Hub brûke. Op dizze faze fan wurk moatte jo it folgjende dwaan:

Ynstallearje Havenarbeider.
Registrearje op de Docker Hub-side.
Meld jo oan by jo akkount troch it folgjende kommando út te fieren yn 'e terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

No moatte jo, mei de terminal, gean nei de map sa-frontend en fier dêr it folgjende kommando út:

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

Hjir en hjirûnder yn ferlykbere kommando's $DOCKER_USER_ID moat wurde ferfongen troch jo brûkersnamme op Docker Hub. Dit diel fan it kommando kin bygelyks sa útsjen: rinormaloku/sentiment-analysis-frontend.

Yn dit gefal kin dit kommando ynkoarte wurde troch derút te ferwiderjen -f Dockerfile, om't de map wêryn wy dit kommando útfiere dit bestân al hat.

Om de ôfmakke ôfbylding nei it repository te stjoeren, hawwe wy it folgjende kommando nedich:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Nei it foltôgjen, kontrolearje jo list mei repositories op Docker Hub om te sjen oft de ôfbylding mei súkses nei de wolkopslach is stjoerd.

▍ In kontener begjinne

No kin elkenien de ôfbylding downloade en útfiere bekend as $DOCKER_USER_ID/sentiment-analysis-frontend. Om dit te dwaan, moatte jo de folgjende folchoarder fan kommando's útfiere:

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

No rint de kontener, en wy kinne fierder wurkje troch oare ôfbyldings te meitsjen dy't wy nedich binne. Mar foardat wy trochgean, litte wy it ûntwerp begripe 80:80, dat is fûn yn it kommando om de ôfbylding út te fieren en kin betiizjend lykje.

Earste nûmer 80 is it poartenûmer fan de host (dat is de lokale kompjûter).
Twadde nûmer 80 is de haven fan de kontener dêr't it fersyk nei omlaat wurde moat.

Beskôgje de folgjende yllustraasje.

Port Forwarding

It systeem stjoert fersiken fan 'e haven troch <hostPort> nei de haven <containerPort>. Dat is, tagong ta de haven 80 kompjûter wurdt omlaat nei in poarte 80 kontener.

Sûnt de haven 80 iepene op 'e lokale kompjûter, kinne jo tagong krije ta de applikaasje fan dizze kompjûter op localhost:80. As jo systeem Docker net stipet, kinne jo de applikaasje útfiere op in Docker-firtuele masine, wêrfan it adres derút liket <docker-machine ip>:80. Om it IP-adres fan 'e Docker-firtuele masine te finen, kinne jo it kommando brûke docker-machine ip.

Op dit punt, neidat jo de kontener fan 'e front-end-applikaasje mei súkses hawwe lansearre, soene jo de side yn in browser moatte kinne iepenje.

▍.dockerignore triem

It bouwen fan it applikaasjeôfbylding SA-Frontend, wy koenen fernimme dat dit proses is ekstreem stadich. Dit is om't de kontekst fan 'e ôfbyldingsbou moat wurde stjoerd nei de Docker-daemon. De map dy't de bouwkontekst fertsjintwurdiget wurdt jûn as it lêste argumint foar it kommando docker build. Yn ús gefal is d'r in punt oan 'e ein fan dit kommando. Dit resultearret yn 'e folgjende struktuer wurdt opnommen yn' e gearstalling kontekst:

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

Mar fan alle mappen dy't hjir oanwêzich binne, hawwe wy allinich in map nedich build. Wat oars downloade is in fergriemerij fan tiid. Jo kinne de bou fersnelle troch Docker te fertellen hokker mappen te negearje. Om dit te dwaan, hawwe wy in bestân nedich .dockerignore. Jo, as jo binne bekend mei de triem .gitignore, sil de struktuer fan dit bestân wierskynlik fertroud lykje. It listet mappen dy't it byldbousysteem negearje kin. Yn ús gefal sjocht de ynhâld fan dit bestân der sa út:

node_modules
src
public

file .dockerignore moat yn deselde map wêze as it bestân Dockerfile. No sil de gearstalling fan 'e ôfbylding in pear sekonden nimme.

Litte wy no omgean mei de ôfbylding foar in Java-applikaasje.

▍ Bouwe in kontenerôfbylding foar in Java-applikaasje

Jo witte wat, en jo hawwe al alles leard dat jo nedich binne om kontenerôfbyldings te meitsjen. Dêrom sil dizze paragraaf tige koart wêze.

Iepenje de triem Dockerfile, dy't leit yn 'e projektmap sa-webapp. As jo de tekst fan dit bestân lêze, dan sille jo deryn mar twa nije konstruksjes moetsje dy't begjinne mei trefwurden ENV и EXPOSE:

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

Keyword ENV kinne jo omjouwingsfariabelen yn Docker-kontainers ferklearje. Benammen yn ús gefal kinne jo in URL ynstelle om tagong te krijen ta de API fan 'e applikaasje dy't tekstanalyse útfiert.

Keyword EXPOSE lit jo Docker fertelle om in poarte te iepenjen. Wy sille dizze poarte brûke as wy wurkje mei de applikaasje. Hjir kinne jo sjen dat yn Dockerfile foar tapassing SA-Frontend der is gjin sa'n kommando. Dit is allinich foar dokumintaasjedoelen, mei oare wurden, dit konstruksje is foar de lêzer Dockerfile.

It bouwen fan de ôfbylding en triuwe it nei de repository liket krekt as it foarige foarbyld. As jo noch net heul fertrouwen binne yn jo kapasiteiten, kinne jo de oerienkommende kommando's fine yn it bestân README.md yn map sa-webapp.

▍ Bouwe in kontenerôfbylding foar in Python-applikaasje

As jo nei de ynhâld fan 'e triem sjogge Dockerfile yn map sa-logicdêr fine jo neat nijs. De kommando's foar it bouwen fan de ôfbylding en it triuwen nei it repository moatte jo al bekend wêze, mar, lykas yn it gefal fan ús oare applikaasjes, kinne se fûn wurde yn it bestân README.md yn map sa-logic.

▍Containerisearre applikaasjes testen

Kinne jo wat fertrouwe dat jo net hawwe testen? Ik kin ek net. Litte wy ús konteners testen.

Litte wy de applikaasjekontainer begjinne sa-logic en konfigurearje it om op in haven te harkjen 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Litte wy de applikaasjekontainer begjinne sa-webapp en konfigurearje it om op in haven te harkjen 8080. Derneist moatte wy de poarte ynstelle wêrop de Python-applikaasje harket nei fersiken fan 'e Java-applikaasje troch de omjouwingsfariabele opnij te jaan 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
```

Om te learen hoe't jo it IP-adres fan in kontener as Docker VM kinne fine, ferwize nei it bestân README.

Litte wy de applikaasjekontainer begjinne sa-frontend:

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

No is alles klear om te navigearjen yn 'e browser nei it adres localhost:80 en test de app.

Tink derom dat as jo feroarje de haven foar sa-webapp, of as jo in Docker VM útfiere, moatte jo it bestân bewurkje App.js fan map sa-frontendtroch it feroarjen fan it IP-adres of poartenûmer yn 'e metoade analyzeSentence()troch aktuele ynformaasje te ferfangen ynstee fan ferâldere gegevens. Dêrnei moatte jo de ôfbylding opnij gearstalle en it brûke.

Dit is hoe't ús applikaasjediagram der no útsjocht.

Mikrotsjinsten rinne yn konteners

Gearfetting: wêrom hawwe wy in Kubernetes-kluster nedich?

Wy hawwe krekt de bestannen besjoen Dockerfile, praat oer hoe't jo ôfbyldings bouwe kinne en se nei in Docker-repository triuwe. Derneist hawwe wy leard hoe't jo de gearstalling fan ôfbyldings kinne fersnelle mei it bestân .dockerignore. As resultaat rinne ús mikrotsjinsten no yn Docker-konteners. Hjir kinne jo in folslein rjochtfeardige fraach hawwe oer wêrom't wy Kubernetes nedich binne. It antwurd op dizze fraach sil wijd wurde oan it twadde diel fan dit materiaal. Yn 'e tuskentiid beskôgje de folgjende fraach:
Litte wy oannimme dat ús webapplikaasje foar tekstanalyse wrâldwiid populêr is wurden. Elke minút komme miljoenen oanfragen by him. Dit betsjut dat mikrotsjinsten sa-webapp и sa-logic sil ûnder enoarme stress wêze. Hoe konteners te skaaljen dy't mikrotsjinsten útfiere?

Boarne: www.habr.com

Kubernetes Tutorial Diel 1: Applikaasjes, mikrotsjinsten en konteners