🥇Kubernetes Tutoriaal Deel 1: Toepassings, mikrodienste en houers

Op ons versoek het Habr 'n spilpunt geskep Kubernetes en ons is bly om die eerste publikasie daarin te plaas. Teken in!

Kubernetes is maklik. Hoekom betaal banke vir my baie geld om in hierdie area te werk, terwyl enigiemand hierdie tegnologie binne net 'n paar uur kan bemeester?

As jy twyfel of Kubernetes so vinnig aangeleer kan word, stel ek voor dat jy dit self probeer doen. Nadat u hierdie materiaal bemeester het, sal u naamlik in staat wees om 'n toepassing gebaseer op mikrodienste in 'n Kubernetes-kluster te laat loop. Ek kan dit waarborg, want dit is in dieselfde metodologie wat ek hier gebruik dat ek ons kliënte leer hoe om met Kubernetes te werk. Wat maak hierdie gids anders as ander? Eintlik baie dinge. So, die meeste van hierdie materiaal begin met 'n verduideliking van eenvoudige dinge - die konsepte van Kubernetes en die kenmerke van die kubectl-opdrag. Die skrywers van hierdie artikels neem aan dat hul leser vertroud is met toepassingsontwikkeling, mikrodienste en Docker-houers. Ons sal anderpad gaan. Kom ons praat eers oor hoe om 'n toepassing gebaseer op mikrodienste op 'n rekenaar te laat loop. Dan sal ons kyk na die bou van houerbeelde vir elke mikrodiens. En daarna sal ons kennis maak met Kubernetes en die ontplooiing van 'n toepassing wat op mikrodienste gebaseer is in 'n groep wat deur Kubernetes bestuur word, ontleed.

Hierdie benadering, met 'n geleidelike benadering tot Kubernetes, sal die diepte van begrip gee van wat besig is om te gebeur wat die gemiddelde mens nodig het om te verstaan hoe eenvoudig alles in Kubernetes gerangskik is. Kubernetes is beslis 'n eenvoudige tegnologie, mits wie dit wil bemeester, weet waar en hoe dit gebruik word.

Nou, sonder meer, laat ons aan die werk begin en praat oor die toepassing waarmee ons gaan werk.

Eksperimentele toepassing

Ons toepassing sal slegs een funksie verrig. Dit neem, as inset, een sin, waarna dit, met behulp van teksanalise-instrumente, 'n sentimentanalise van hierdie sin uitvoer, wat 'n beoordeling verkry van die emosionele houding van die skrywer van die sin tot 'n sekere voorwerp.

Dit is hoe die hoofvenster van hierdie toepassing lyk.

Sentimentanalise Webtoepassing

Vanuit 'n tegniese oogpunt bestaan die toepassing uit drie mikrodienste, wat elkeen 'n sekere stel take oplos:

SA-Frontend is 'n Nginx-webbediener wat React statiese lêers bedien.
SA-WebApp is 'n webtoepassing wat in Java geskryf is wat versoeke vanaf die frontend hanteer.
SA-Logic is 'n Python-toepassing wat tekssentimentanalise uitvoer.

Dit is belangrik om daarop te let dat mikrodienste nie in isolasie bestaan nie. Hulle implementeer die idee van "skeiding van pligte", maar hulle moet terselfdertyd met mekaar kommunikeer.

Data vloei in die toepassing

In die bostaande diagram kan jy die genommerde stadiums van die stelsel sien, wat die datavloei in die toepassing illustreer. Kom ons breek hulle af:

Die blaaier versoek 'n lêer vanaf die bediener index.html (wat op sy beurt die React-toepassingspakket laai).
Die gebruiker interaksie met die toepassing, dit veroorsaak 'n oproep na 'n webtoepassing gebaseer op Lente.
Die webtoepassing stuur die versoek om die teks te ontleed na die Python-toepassing aan.
Die Python-toepassing ontleed die sentiment van die teks en gee die resultaat terug as 'n reaksie op die versoek.
Die Spring-toepassing stuur 'n reaksie na die React-toepassing (wat op sy beurt die resultaat van die ontleed teks aan die gebruiker wys).

Die kode vir al hierdie toepassings kan gevind word hier. Ek beveel aan dat jy hierdie bewaarplek nou na jouself kopieer, aangesien daar baie interessante eksperimente daarmee voorlê.

Begin 'n toepassing gebaseer op mikrodienste op die plaaslike masjien

Om die toepassing te laat werk, moet ons al drie mikrodienste begin. Kom ons begin met die mooiste van hulle - die voorkant-toepassing.

▍Opstel van React vir plaaslike ontwikkeling

Om 'n React-toepassing te laat loop, moet jy die Node.js-raamwerk en NPM op jou rekenaar installeer. Nadat u dit alles geïnstalleer het, gaan met die terminale na die projeklêergids sa-frontend en voer die volgende opdrag uit:

npm install

Deur hierdie opdrag in die gids uit te voer node_modules die afhanklikhede van die React-toepassing sal gelaai word, waarvan die rekords in die lêer is package.json. Nadat u die afhanklikhede in dieselfde gids afgelaai het, voer die volgende opdrag uit:

npm start

Dis al. Die React-toepassing loop nou en kan verkry word deur na die blaaieradres te navigeer localhost:3000. Jy kan iets in sy kode verander. U sal dadelik die effek van hierdie veranderinge in die blaaier sien. Dit is moontlik danksy die sogenaamde "warm" vervanging van modules. Danksy dit verander front-end-ontwikkeling in 'n eenvoudige en aangename ervaring.

▍ Berei 'n React-toepassing voor vir produksie

Vir die doel om werklik 'n React-toepassing te gebruik, moet ons dit omskep in 'n stel statiese lêers en dit aan kliënte bedien wat 'n webbediener gebruik.

Om die React-toepassing te bou, gebruik weer die terminale, navigeer na die gids sa-frontend en voer die volgende opdrag uit:

npm run build

Dit sal 'n gids in die projekgids skep build. Dit sal al die statiese lêers bevat wat nodig is vir die React-toepassing om te werk.

▍Bedien statiese lêers met Nginx

Eerstens moet u die Nginx-webbediener installeer en laat loop. Hier jy kan dit aflaai en instruksies vind om dit te installeer en uit te voer. Dan moet jy die inhoud van die gids kopieer sa-frontend/build na die gids [your_nginx_installation_dir]/html.

Met hierdie benadering word die lêer gegenereer tydens die samestelling van die React-toepassing index.html sal beskikbaar wees by [your_nginx_installation_dir]/html/index.html. Dit is die lêer wat die Nginx-bediener by verstek uitreik wanneer dit toegang kry. Die bediener is gekonfigureer om op 'n poort te luister 80, maar jy kan dit pasmaak soos jy wil deur die lêer te wysig [your_nginx_installation_dir]/conf/nginx.conf.

Maak nou jou blaaier oop en gaan na localhost:80. Jy sal die React-toepassingsbladsy sien.

Reageer-app bedien deur Nginx-bediener

As jy nou iets in die veld invoer Type your sentence en druk die knoppie Send - niks sal gebeur nie. Maar as jy na die konsole kyk, kan jy foutboodskappe daar sien. Om presies te verstaan waar hierdie foute voorkom, kom ons ontleed die toepassingskode.

▍ Ontleding van die kode van die front-end aansoek

Kyk na die lêer se kode App.js, kan ons dit sien deur op die knoppie te klik Send roep 'n metode analyzeSentence(). Die kode vir hierdie metode word hieronder getoon. Op dieselfde tyd, let op die feit dat vir elke reël waarop daar 'n opmerking van die vorm is # Номер, is daar 'n verduideliking wat onder die kode gegee word. Op dieselfde manier sal ons ander kodefragmente ontleed.

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. Die URL waarheen die POST-versoek gedoen word. Daar word aanvaar dat hierdie adres 'n aansoek is wat op sulke versoeke wag.

2.Die versoekliggaam wat aan die aansoek gestuur is. Hier is 'n voorbeeld van 'n versoekliggaam:

{
    sentence: "I like yogobella!"
}

3.Wanneer 'n antwoord op 'n versoek ontvang word, word die toestand van die komponent opgedateer. Dit veroorsaak dat die komponent herweergegee word. As ons data ontvang (dit wil sê 'n JSON-objek wat die ingevoerde data en die berekende tekstelling bevat), sal ons die komponent uitvoer Polaritysolank daar aan die voorwaardes voldoen word. Hier is hoe ons die komponent beskryf:

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

Dit lyk of die kode redelik goed werk. Wat is in elk geval fout hier? As jy aanneem dat daar by die adres waarheen die aansoek 'n POST-versoek probeer stuur, nog niks is wat hierdie versoek kan aanvaar en verwerk nie, dan sal jy heeltemal reg wees. Naamlik om versoeke te verwerk wat na die adres kom http://localhost:8080/sentiment, moet ons 'n webtoepassing laat loop wat op Spring gebaseer is.

Ons benodig 'n Lente-aansoek wat 'n POST-versoek kan aanvaar

▍Opstel van 'n webtoepassing gebaseer op Lente

Om 'n Spring-toepassing te ontplooi, benodig jy JDK8 en Maven en behoorlik gekonfigureerde omgewingsveranderlikes. Nadat u dit alles geïnstalleer het, kan u voortgaan om aan ons projek te werk.

▍Verpak die toepassing in 'n jar-lêer

Navigeer, met behulp van die terminaal, na die gids sa-webapp en voer die volgende opdrag in:

mvn install

Nadat u hierdie opdrag in die gids uitgevoer het sa-webapp gids sal geskep word target. Dit is waar die Java-toepassing geleë sal wees, verpak in 'n jar-lêer, verteenwoordig deur die lêer sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ Begin 'n Java-toepassing

Gaan na die gids target en voer die toepassing uit met die volgende opdrag:

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

'n Fout sal voorkom tydens die uitvoering van hierdie opdrag. Om dit te begin regmaak, kan ons die uitsonderingsbesonderhede in die stapelspoordata ontleed:

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

Vir ons is die belangrikste hier die vermelding van die onmoontlikheid om die betekenis op te klaar sa.logic.api.url. Kom ons ontleed die kode waar die fout voorkom.

▍ Java-toepassingskode-analise

Hier is die kodebrokkie waar die fout voorkom.

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

In SentimentController daar is 'n veld saLogicApiUrl. Die waarde daarvan word deur die eiendom bepaal sa.logic.api.url.
ry saLogicApiUrl verbind met waarde /analyse/sentiment. Saam vorm hulle 'n adres om 'n oproep te maak na die mikrodiens wat teksontleding doen.

▍ Stel 'n eiendomswaarde in

In die lente is die verstekbron van eiendomswaardes 'n lêer application.properties, wat gevind kan word by sa-webapp/src/main/resources. Maar die gebruik daarvan is nie die enigste manier om eiendomswaardes te stel nie. U kan dit ook doen met die volgende opdrag:

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

Die waarde van hierdie eiendom moet na die adres van ons Python-toepassing wys.

Deur dit op te stel, vertel ons die Spring-webtoepassing waarheen dit moet gaan om teksontledingsversoeke te maak.

Om nie ons lewens te kompliseer nie, sal ons besluit dat die Python-toepassing beskikbaar sal wees by localhost:5000 en probeer om nie daarvan te vergeet nie. As gevolg hiervan sal die opdrag om die Lente-toepassing te begin soos volg lyk:

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

Ons stelsel ontbreek 'n Python-toepassing

Nou moet ons net die Python-toepassing laat loop en die stelsel sal werk soos verwag.

▍Opstel van 'n Python-toepassing

Om 'n Python-toepassing te laat loop, moet jy Python 3 en Pip geïnstalleer hê, en jy moet die toepaslike omgewingsveranderlikes korrek gestel hê.

▍Installeer afhanklikhede

Gaan na die projekgids sa-logic/sa en voer die volgende opdragte uit:

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

▍App bekendstelling

Met die afhanklikhede geïnstalleer, is ons gereed om die toepassing te laat loop:

python sentiment_analysis.py

Nadat u hierdie opdrag uitgevoer het, sal ons die volgende vertel:

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

Dit beteken dat die toepassing loop en wag vir versoeke by localhost:5000/

▍Kode navorsing

Kom ons kyk na die Python-toepassingskode om te verstaan hoe dit op versoeke reageer:

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

Voorwerpinitialisasie Flask.
Spesifikasie van die adres vir die maak van POST-versoeke daaraan.
Herwinning van 'n eiendom sentence van die versoekliggaam.
Inisialisering van anonieme voorwerp TextBlob en die waarde te kry polarity vir die eerste voorstel wat in die liggaam van die versoek ontvang is (in ons geval is dit die enigste voorstel wat vir ontleding ingedien is).
Terugstuur van 'n antwoord, waarvan die liggaam die teks van die aanbod bevat en die aanwyser wat daarvoor bereken is polarity.
Die bekendstelling van die Flask-toepassing, wat beskikbaar sal wees by 0.0.0.0:5000 (jy kan ook toegang daartoe kry deur 'n konstruksie van die vorm te gebruik localhost:5000).

Nou loop die mikrodienste waaruit die toepassing bestaan. Hulle is ingestel om met mekaar te kommunikeer. Hier is hoe die toepassingsdiagram op hierdie stadium van werk lyk.

Alle mikrodienste waaruit die toepassing bestaan, word in 'n gesonde toestand gebring

Nou, voordat ons voortgaan, maak die React-toepassing in 'n blaaier oop en probeer 'n sin daarmee ontleed. As alles korrek gedoen is - nadat u die knoppie gedruk het Send jy sal die ontledingsresultate onder die tekskassie sien.

In die volgende afdeling sal ons praat oor hoe om ons mikrodienste in Docker-houers uit te voer. Dit is nodig om die toepassing voor te berei om in die Kubernetes-kluster te loop.

Docker-houers

Kubernetes is 'n stelsel vir die outomatisering van die ontplooiing, skaal en bestuur van houertoepassings. Dit word ook 'n "houer-orkeseerder" genoem. As Kubernetes met houers werk, moet ons eers hierdie houers bekom voordat ons hierdie stelsel gebruik. Maar eers, kom ons praat oor wat houers is. Miskien kan die beste antwoord op die vraag wat dit is gevind word in dokumentasie aan Docker:

'n Houerbeeld is 'n liggewig, selfstandige, uitvoerbare pakket wat 'n toepassing bevat, wat alles insluit wat nodig is om dit te laat loop: toepassingskode, looptydomgewing, stelselnutsgoed en -biblioteke, instellings. Houerprogramme kan in beide Linux- en Windows-omgewings gebruik word en sal altyd dieselfde werk, ongeag die infrastruktuur.

Dit beteken dat houers op enige rekenaar uitgevoer kan word, insluitend produksiebedieners, en in enige omgewing sal die toepassings wat daarin vervat is, op dieselfde manier werk.

Om die kenmerke van houers te verken en dit te vergelyk met ander maniere om toepassings te laat loop, kom ons kyk na die voorbeeld van die bediening van 'n React-toepassing met behulp van 'n virtuele masjien en 'n houer.

▍Bedien statiese lêers van 'n React-toepassing met behulp van 'n virtuele masjien

As ons probeer om die instandhouding van statiese lêers met behulp van virtuele masjiene te organiseer, sal ons die volgende nadele ondervind:

Ondoeltreffende gebruik van hulpbronne, aangesien elke virtuele masjien 'n volledige bedryfstelsel is.
Platform afhanklikheid. Wat op 'n plaaslike rekenaar werk, werk dalk nie op 'n produksiebediener nie.
Stadige en hulpbron intensiewe skaal van 'n virtuele masjien oplossing.

Nginx-webbediener wat statiese lêers bedien wat in 'n virtuele masjien loop

As houers gebruik word om 'n soortgelyke probleem op te los, kan die volgende sterk punte in vergelyking met virtuele masjiene opgemerk word:

Doeltreffende gebruik van hulpbronne: werk met die bedryfstelsel deur Docker te gebruik.
Platform onafhanklikheid. 'n Houer wat 'n ontwikkelaar op hul eie rekenaar kan laat loop, sal enige plek loop.
Liggewig ontplooiing deur die gebruik van beeldlae.

Nginx-webbediener wat statiese lêers bedien wat in 'n houer loop

Ons het slegs virtuele masjiene en houers op 'n paar punte vergelyk, maar selfs dit is genoeg om 'n gevoel te kry vir die sterk punte van houers. Hier U kan besonderhede oor Docker-houers vind.

▍ Bou 'n houerbeeld vir 'n React-toepassing

Die basiese bousteen van 'n Docker-houer is die lêer Dockerfile. Aan die begin van hierdie lêer word 'n basisbeeld van die houer aangeteken, dan word 'n reeks instruksies ingesluit wat aandui hoe om 'n houer te skep wat aan die behoeftes van 'n toepassing sal voldoen.

Voordat ons met die lêer begin werk Dockerfile, onthou wat ons gedoen het om die lêers van die React-toepassing voor te berei vir oplaai na die Nginx-bediener:

Bou 'n React-toepassingspakket (npm run build).
Begin die Nginx-bediener.
Kopieer die inhoud van 'n gids build uit die projekmap sa-frontend na die bedienergids nginx/html.

Hieronder kan u die parallelle sien tussen die skep van 'n houer en die bogenoemde aksies wat op die plaaslike rekenaar uitgevoer word.

▍ Voorbereiding van 'n Docker-lêer vir die SA-frontend-toepassing

Instruksies wat by ingesluit moet word Dockerfile vir aansoek SA-Frontend, bestaan uit slegs twee opdragte. Die feit is dat die Nginx-ontwikkelingspan 'n basiese voorberei het beeld vir Nginx, wat ons sal gebruik om ons beeld te bou. Hier is die twee stappe wat ons moet beskryf:

Jy moet die Nginx-beeld die basis van die beeld maak.
Voer inhoud sa-frontend/build moet na die beeldlêergids kopieer nginx/html.

As ons van hierdie beskrywing na die lêer gaan Dockerfile, dan sal dit so lyk:

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

Soos u kan sien, is alles hier baie eenvoudig, terwyl die inhoud van die lêer selfs redelik leesbaar en verstaanbaar blyk te wees. Hierdie lêer vertel die stelsel om die prent te neem nginx met alles wat dit reeds het, en kopieer die inhoud van die gids build na die gids nginx/html.

Hier het jy dalk 'n vraag oor hoe ek weet waar presies om die lêers uit die gids te kopieer build, dit wil sê waar het die pad vandaan gekom /usr/share/nginx/html. Eintlik is hier ook niks ingewikkeld nie. Die feit is dat die relevante inligting gevind kan word in beskrywing beeld.

▍Om die prent saam te stel en dit op te laai na die bewaarplek

Voordat ons met 'n voltooide prent kan werk, moet ons dit by die beeldbewaarplek indien. Om dit te doen, sal ons die gratis wolkgebaseerde beeldgasheerplatform Docker Hub gebruik. Op hierdie stadium van werk moet jy die volgende doen:

Om te installeer Docker.
Registreer op die Docker Hub-werf.
Meld aan by jou rekening deur die volgende opdrag in die terminaal uit te voer:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Nou moet jy, met die terminaal, na die gids gaan sa-frontend en voer die volgende opdrag daar uit:

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

Hier en onder in soortgelyke opdragte $DOCKER_USER_ID moet vervang word met jou gebruikersnaam op Docker Hub. Byvoorbeeld, hierdie deel van die opdrag kan soos volg lyk: rinormaloku/sentiment-analysis-frontend.

In hierdie geval kan hierdie opdrag verkort word deur daarvan te verwyder -f Dockerfile, aangesien die gids waarin ons hierdie opdrag uitvoer reeds hierdie lêer het.

Om die voltooide prent na die bewaarplek te stuur, benodig ons die volgende opdrag:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Nadat u dit voltooi het, gaan u lys van bewaarplekke op Docker Hub na om te sien of die prent suksesvol na die wolkberging gestoot is.

▍ Begin 'n houer

Nou kan enigiemand die prent wat bekend staan as, aflaai en laat loop $DOCKER_USER_ID/sentiment-analysis-frontend. Om dit te kan doen, moet jy die volgende volgorde van opdragte uitvoer:

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

Nou loop die houer, en ons kan voortgaan om te werk deur ander beelde te skep wat ons benodig. Maar voordat ons voortgaan, laat ons die ontwerp verstaan 80:80, wat gevind word in die opdrag om die prent uit te voer en kan dalk verwarrend lyk.

Eerste nommer 80 is die poortnommer van die gasheer (dit is die plaaslike rekenaar).
Tweede nommer 80 is die hawe van die houer waarheen die versoek herlei moet word.

Beskou die volgende illustrasie.

Port Forwarding

Die stelsel stuur versoeke van die hawe af <hostPort> na die hawe <containerPort>. Dit wil sê, toegang tot die hawe 80 rekenaar word na 'n poort herlei 80 houer.

Sedert die hawe 80 oopgemaak op die plaaslike rekenaar, kan jy toegang tot die toepassing vanaf hierdie rekenaar by localhost:80. As jou stelsel nie Docker ondersteun nie, kan jy die toepassing op 'n Docker virtuele masjien laat loop, waarvan die adres sal lyk <docker-machine ip>:80. Om die IP-adres van die Docker virtuele masjien uit te vind, kan u die opdrag gebruik docker-machine ip.

Op hierdie stadium, sodra die voorkant-toepassinghouer suksesvol bekendgestel is, behoort u sy bladsy in 'n blaaier te kan oopmaak.

▍.dockerignore-lêer

Bou die toepassingsbeeld SA-Frontend, kon ons agterkom dat hierdie proses uiters stadig is. Dit is omdat die beeldbou-konteks na die Docker-demon gestuur moet word. Die gids wat die bou-konteks verteenwoordig, word as die laaste argument vir die opdrag gegee docker build. In ons geval is daar 'n kolletjie aan die einde van hierdie opdrag. Dit lei daartoe dat die volgende struktuur in die samestellingskonteks ingesluit word:

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

Maar van al die dopgehou wat hier teenwoordig is, het ons net 'n gids nodig build. Om enigiets anders af te laai is 'n mors van tyd. U kan die bou versnel deur vir Docker te vertel watter gidse om te ignoreer. Om dit te kan doen, het ons 'n lêer nodig .dockerignore. Jy, as jy vertroud is met die lêer .gitignore, sal die struktuur van hierdie lêer waarskynlik bekend lyk. Dit lys gidse wat die beeldboustelsel kan ignoreer. In ons geval lyk die inhoud van hierdie lêer soos volg:

node_modules
src
public

lêer .dockerignore moet in dieselfde vouer as die lêer wees Dockerfile. Nou sal die samestelling van die beeld 'n paar sekondes neem.

Kom ons behandel nou die beeld vir 'n Java-toepassing.

▍ Bou 'n houerbeeld vir 'n Java-toepassing

Jy weet wat, en jy het reeds alles geleer wat jy nodig het om houerbeelde te skep. Daarom sal hierdie gedeelte baie kort wees.

Maak die lêer oop Dockerfile, wat in die projeklêer geleë is sa-webapp. As jy die teks van hierdie lêer lees, sal jy daarin net twee nuwe konstruksies ontmoet wat met sleutelwoorde begin ENV и EXPOSE:

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

Sleutelwoord ENV laat jou toe om omgewingsveranderlikes binne Docker-houers te verklaar. In die besonder, in ons geval, laat dit jou toe om 'n URL te stel om toegang te verkry tot die API van die toepassing wat teksanalise uitvoer.

Sleutelwoord EXPOSE laat jou toe om Docker te vertel om 'n poort oop te maak. Ons gaan hierdie poort gebruik terwyl ons met die toepassing werk. Hier kan jy dit sien in Dockerfile vir aansoek SA-Frontend daar is nie so 'n opdrag nie. Dit is slegs vir dokumentasiedoeleindes, met ander woorde, hierdie konstruk is vir die leser Dockerfile.

Om die prent te bou en dit na die bewaarplek te stoot, lyk presies soos die vorige voorbeeld. As jy nog nie baie vertroue in jou vermoëns het nie, kan die ooreenstemmende opdragte in die lêer gevind word README.md in vouer sa-webapp.

▍ Bou 'n houerbeeld vir 'n Python-toepassing

As jy na die inhoud van die lêer kyk Dockerfile in vouer sa-logicjy sal niks nuuts daar vind nie. Die opdragte vir die bou van die prent en stoot dit na die bewaarplek behoort ook aan jou bekend te wees, maar, soos die geval is met ons ander toepassings, kan hulle in die lêer gevind word README.md in vouer sa-logic.

▍Toets van houer-toepassings

Kan jy iets vertrou wat jy nie getoets het nie? Ek kan ook nie. Kom ons toets ons houers.

Kom ons begin die toepassingshouer sa-logic en stel dit op om op 'n poort te luister 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Kom ons begin die toepassingshouer sa-webapp en stel dit op om op 'n poort te luister 8080. Daarbenewens moet ons die poort stel waarop die Python-toepassing sal luister vir versoeke van die Java-toepassing deur die omgewingsveranderlike toe te wys 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 leer hoe om die IP-adres van 'n houer of Docker VM uit te vind, verwys na die lêer README.

Kom ons begin die toepassingshouer sa-frontend:

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

Nou is alles gereed om in die blaaier na die adres te navigeer localhost:80 en toets die toepassing.

Neem asseblief kennis dat as jy die poort vir sa-webapp, of as jy 'n Docker VM gebruik, sal jy die lêer moet wysig App.js uit gids sa-frontenddeur die IP-adres of poortnommer in die metode te verander analyzeSentence()deur huidige inligting te vervang in plaas van verouderde data. Daarna moet jy die prent weer saamstel en dit gebruik.

Dit is hoe ons toepassingsdiagram nou lyk.

Mikrodienste loop in houers

Opsomming: hoekom het ons 'n Kubernetes-kluster nodig?

Ons het pas die lêers nagegaan Dockerfile, gepraat oor hoe om beelde te bou en dit na 'n Docker-bewaarplek te stoot. Daarbenewens het ons geleer hoe om die samestelling van beelde met behulp van die lêer te bespoedig .dockerignore. Gevolglik loop ons mikrodienste nou in Docker-houers. Hier het jy dalk 'n heeltemal geregverdigde vraag oor hoekom ons Kubernetes nodig het. Die antwoord op hierdie vraag sal aan die tweede deel van hierdie materiaal gewy word. Oorweeg intussen die volgende vraag:
Kom ons neem aan dat ons teksanalise-webtoepassing wêreldwyd gewild geword het. Miljoene versoeke kom elke minuut na hom toe. Dit beteken dat mikrodienste sa-webapp и sa-logic sal onder geweldige stres wees. Hoe om houers te skaal wat mikrodienste bestuur?

Bron: will.com

Kubernetes Tutoriaal Deel 1: Toepassings, mikrodienste en houers