🥇Kubernetes Tutorial Parto 1: Aplikoj, Mikroservoj kaj Ujoj

Laŭ nia peto, Habr kreis nabon Kubernetoj kaj ni ĝojas meti la unuan eldonaĵon en ĝi. Abonu!

Kubernetes estas facila. Kial bankoj pagas al mi multe da mono por labori en ĉi tiu areo, dum iu ajn povas regi ĉi tiun teknologion en nur kelkaj horoj?

Se vi dubas, ke Kubernetes povas esti tiel rapide lernita, mi sugestas, ke vi provu fari ĝin mem. Nome, reginte ĉi tiun materialon, vi povos ruli aplikaĵon bazitan sur mikroservoj en Kubernetes-grupo. Mi povas garantii tion, ĉar estas en la sama metodaro, kiun mi uzas ĉi tie, ke mi instruas niajn klientojn kiel labori kun Kubernetes. Kio diferencas ĉi tiun gvidilon de aliaj? Fakte, multaj aferoj. Do, la plej multaj el ĉi tiuj materialoj komenciĝas per klarigo de simplaj aferoj - la konceptoj de Kubernetes kaj la trajtoj de la komando kubectl. La aŭtoroj de ĉi tiuj artikoloj supozas, ke ilia leganto konas aplikaĵon, mikroservojn kaj Docker-ujojn. Ni iros la alian vojon. Unue, ni parolu pri kiel ruli aplikaĵon bazitan sur mikroservoj en komputilo. Poste ni rigardos konstrui ujajn bildojn por ĉiu mikroservo. Kaj post tio, ni konatiĝos kun Kubernetes kaj analizos la disfaldiĝon de aplikaĵo bazita sur mikroservoj en areto administrita de Kubernetes.

Ĉi tiu aliro, kun laŭpaŝa aliro al Kubernetes, donos la profundon de kompreno pri tio, kio okazas, kiun la averaĝa homo bezonas por kompreni kiel simple ĉio estas aranĝita en Kubernetes. Kubernetes certe estas simpla teknologio, kondiĉe ke kiu volas regi ĝin sciu kie kaj kiel ĝi estas uzata.

Nun, sen pli da diro, ni eklaboru kaj parolu pri la aplikaĵo, kun kiu ni laboros.

Eksperimenta aplikaĵo

Nia aplikaĵo plenumos nur unu funkcion. Ĝi prenas, kiel enigaĵon, unu frazon, post kiu, uzante tekst-analizajn ilojn, ĝi faras sentimentanalizon de tiu ĉi frazo, akirante takson de la emocia sinteno de la aŭtoro de la frazo al certa objekto.

Jen kiel aspektas la ĉefa fenestro de ĉi tiu aplikaĵo.

Reta Apliko de Analizo de Sentoj

De teknika vidpunkto, la aplikaĵo konsistas el tri mikroservoj, ĉiu el kiuj solvas certan aron da taskoj:

SA-Frontend estas retservilo Nginx, kiu servas statikajn dosierojn de React.
SA-WebApp estas TTT-apliko skribita en Java kiu pritraktas petojn de la fasado.
SA-Logic estas Python-apliko, kiu realigas tekstsentan analizon.

Gravas noti, ke mikroservoj ne ekzistas izole. Ili efektivigas la ideon de "disigo de devoj", sed ili, samtempe, bezonas interagi unu kun la alia.

Datumoj fluas en la aplikaĵo

En la supra diagramo, vi povas vidi la numeritajn stadiojn de la sistemo, ilustrante la datumfluojn en la aplikaĵo. Ni malkonstruu ilin:

La retumilo petas dosieron de la servilo index.html (kiu siavice ŝarĝas la pakon de la aplikaĵo React).
La uzanto interagas kun la aplikaĵo, tio kaŭzas alvokon al retejo-aplikaĵo bazita sur Spring.
La TTT-apliko plusendas la peton analizi la tekston al la Python-apliko.
La Python-apliko analizas la senton de la teksto kaj resendas la rezulton kiel respondon al la peto.
La Spring-apliko sendas respondon al la React-apliko (kiu siavice montras la rezulton de la analizita teksto al la uzanto).

La kodo por ĉiuj ĉi tiuj aplikoj troveblas tie. Mi rekomendas, ke vi kopiu ĉi tiun deponejon al vi mem nun, ĉar estas multaj interesaj eksperimentoj kun ĝi antaŭ ni.

Ruli aplikaĵon bazitan sur mikroservoj sur la loka maŝino

Por ke la aplikaĵo funkciu, ni devas komenci ĉiujn tri mikroservojn. Ni komencu per la plej bela el ili - la antaŭa aplikaĵo.

▍Starigi React por loka evoluo

Por ruli React-aplikaĵon, vi devas instali la kadron Node.js kaj NPM en via komputilo. Post kiam vi instalis ĉion ĉi, iru uzante la terminalon al la projekta dosierujo sa-frontend kaj rulu la sekvan komandon:

npm install

Ekzekutante ĉi tiun komandon en la dosierujo node_modules la dependecoj de la aplikaĵo React estos ŝarĝitaj, kies registroj estas en la dosiero package.json. Post elŝuto de la dependecoj en la sama dosierujo, rulu la sekvan komandon:

npm start

Tio estas ĉio. La React-programo nun funkcias kaj alireblas navigante al la retumila adreso localhost:3000. Vi povas ŝanĝi ion en lia kodo. Vi tuj vidos la efikon de ĉi tiuj ŝanĝoj en la retumilo. Ĉi tio eblas danke al la tiel nomata "varma" anstataŭigo de moduloj. Dank' al ĉi tio, antaŭa disvolviĝo fariĝas simpla kaj ĝua sperto.

▍Preparante React-apon por produktado

Por efektive uzi React-apon, ni devas konverti ĝin en aron da senmovaj dosieroj kaj servi ilin al klientoj uzante retservilon.

Por konstrui la apon React, denove uzante la terminalon, navigu al la dosierujo sa-frontend kaj rulu la sekvan komandon:

npm run build

Ĉi tio kreos dosierujon en la projekta dosierujo build. Ĝi enhavos ĉiujn senmovajn dosierojn necesajn por ke la aplikaĵo React funkciu.

▍Servante statikajn dosierojn kun Nginx

Unue vi devas instali kaj ruli la retservilon Nginx. estas vi povas elŝuti ĝin kaj trovi instrukciojn por instali kaj ruli ĝin. Tiam vi devas kopii la enhavon de la dosierujo sa-frontend/build al dosierujo [your_nginx_installation_dir]/html.

Kun ĉi tiu aliro, la dosiero generita dum la muntado de la apliko React index.html estos disponebla ĉe [your_nginx_installation_dir]/html/index.html. Ĉi tiu estas la dosiero, kiun la Nginx-servilo eldonas, defaŭlte, kiam ili aliras ĝin. La servilo estas agordita por aŭskulti sur haveno 80, sed vi povas personecigi ĝin kiel vi volas redaktante la dosieron [your_nginx_installation_dir]/conf/nginx.conf.

Nun malfermu vian retumilon kaj iru al localhost:80. Vi vidos la paĝon de la programo React.

React-apo servita de Nginx-servilo

Se vi nun enigu ion en la kampon Type your sentence kaj premu la butonon Send — nenio okazos. Sed, se vi rigardas la konzolon, vi povas vidi erarmesaĝojn tie. Por kompreni ĝuste kie ĉi tiuj eraroj okazas, ni analizu la aplikaĵokodon.

▍Analizo de la kodo de la antaŭa aplikaĵo

Rigardante la kodon de la dosiero App.js, ni povas vidi tion alklakante la butonon Send nomas metodo analyzeSentence(). La kodo por ĉi tiu metodo estas montrita sube. Samtempe atentu la fakton, ke por ĉiu linio, al kiu estas komento de la formo # Номер, estas klarigo donita sub la kodo. En la sama maniero, ni analizos aliajn kodfragmentojn.

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. La URL al kiu la POST-peto estas farita. Ĉi tiu adreso supozeble estas aplikaĵo atendanta tiajn petojn.

2.La peta korpo sendita al la aplikaĵo. Jen ekzemplo de petokorpo:

{
    sentence: "I like yogobella!"
}

3.Kiam respondo al peto estas ricevita, la stato de la komponento estas ĝisdatigita. Ĉi tio igas la komponanton re-prezenti. Se ni ricevas datumojn (tio estas, JSON-objekto enhavanta la enigitajn datumojn kaj la kalkulitan tekstan poentaron), ni eligos la komponanton. Polaritykondiĉe ke la kondiĉoj estas plenumitaj. Jen kiel ni priskribas la komponanton:

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

La kodo ŝajnas funkcii sufiĉe bone. Kio estas ĉi tie, ĉiuokaze? Se vi supozas, ke ĉe la adreso, al kiu la aplikaĵo provas sendi POST-peton, ankoraŭ nenio povas akcepti kaj prilabori ĉi tiun peton, tiam vi tute pravos. Nome, prilabori petojn venantajn al la adreso http://localhost:8080/sentiment, ni devas ruli TTT-aplikaĵon bazitan sur Spring.

Ni bezonas Spring-aplikaĵon kiu povas akcepti POST-peton

▍Agordi TTT-aplikaĵon bazitan sur Spring

Por deploji Spring-aplikaĵon, vi bezonas JDK8 kaj Maven kaj taŭge agorditajn mediovariablojn. Post kiam vi instalos ĉion ĉi, vi povas daŭrigi labori pri nia projekto.

▍Paki la aplikaĵon en jardosieron

Navigu, uzante la terminalon, al la dosierujo sa-webapp kaj enigu la jenan komandon:

mvn install

Post ekzekuti ĉi tiun komandon en la dosierujo sa-webapp dosierujo estos kreita target. Ĉi tie troviĝos la Java aplikaĵo, pakita en jardosiero, reprezentita per la dosiero sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ Lanĉante Java-Aplikon

Iru al la dosierujo target kaj rulu la aplikaĵon per la sekva komando:

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

Eraro okazos dum plenumado de ĉi tiu komando. Por komenci ripari ĝin, ni povas analizi la esceptajn detalojn en la stakaj spuraj datumoj:

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

Por ni, la plej grava afero ĉi tie estas la mencio de la neeblo klarigi la signifon sa.logic.api.url. Ni analizu la kodon kie okazas la eraro.

▍Java aplikaĵa kodanalizo

Jen la koda fragmento, kie okazas la eraro.

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

En SentimentController estas kampo saLogicApiUrl. Ĝia valoro estas fiksita de la posedaĵo sa.logic.api.url.
Linio saLogicApiUrl kunligas kun valoro /analyse/sentiment. Kune ili formas adreson por voki la mikroservon, kiu faras tekstan analizon.

▍Fiksi posedaĵvaloron

En Printempo, la defaŭlta fonto de posedaĵvaloroj estas dosiero application.properties, kiu troviĝas ĉe sa-webapp/src/main/resources. Sed uzi ĝin ne estas la sola maniero agordi posedaĵvalorojn. Vi ankaŭ povas fari tion per la sekva komando:

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

La valoro de ĉi tiu posedaĵo devus montri al la adreso de nia Python-aplikaĵo.

Agordante ĝin, ni diras al la retejo Spring-apliko, kien ĝi devas iri por ekzekuti tekstajn analizajn petojn.

Por ne kompliki nian vivon, ni decidos, ke la aplikaĵo Python estos disponebla ĉe localhost:5000 kaj provu ne forgesi pri ĝi. Kiel rezulto, la komando por lanĉi la Spring-aplikaĵon aspektos jene:

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

Nia sistemo mankas Python-aplikaĵo

Nun ni nur devas ruli la Python-aplikaĵon kaj la sistemo funkcios kiel atendite.

▍Agordi Python-aplikaĵon

Por ruli Python-aplikaĵon, vi devas havi Python 3 kaj Pip instalitajn, kaj vi devas havi la taŭgajn mediajn variablojn ĝuste agordita.

▍Instali dependencojn

Iru al projekta dosierujo sa-logic/sa kaj rulu la jenajn komandojn:

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

▍Lanĉo de aplikaĵo

Kun la dependecoj instalitaj, ni pretas ruli la aplikaĵon:

python sentiment_analysis.py

Post ekzekuto de ĉi tiu komando, ni diros la jenon:

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

Ĉi tio signifas, ke la aplikaĵo funkcias kaj atendas petojn ĉe localhost:5000/

▍Kodesplorado

Ni rigardu la Python-aplikkodon por kompreni kiel ĝi respondas al petoj:

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

Objekto inicialigo Flask.
Specifante la adreson por fari POST-petojn al ĝi.
Reakiro de posedaĵo sentence de la peta korpo.
Anonima objekta inicialigo TextBlob kaj akiri la valoron polarity por la unua propono ricevita en la korpo de la peto (en nia kazo, tio estas la nura propono prezentita por analizo).
Revenante respondon, kies korpo enhavas la tekston de la oferto kaj la indikilon kalkulitan por ĝi polarity.
Lanĉante la aplikaĵon Flask, kiu estos disponebla ĉe 0.0.0.0:5000 (vi ankaŭ povas aliri ĝin uzante konstruon de la formo localhost:5000).

Nun funkcias la mikroservoj, kiuj konsistigas la aplikaĵon. Ili estas pretaj interagi unu kun la alia. Jen kiel aspektas la aplika diagramo en ĉi tiu etapo de laboro.

Ĉiuj mikroservoj kiuj konsistigas la aplikaĵon estas alportitaj al sana stato

Nun, antaŭ ol ni daŭrigu, malfermu la apon React en retumilo kaj provu analizi iun frazon per ĝi. Se ĉio estas farita ĝuste - post premado de la butono Send vi vidos la analizrezultojn sub la tekstujo.

En la sekva sekcio, ni parolos pri kiel ruli niajn mikroservojn en Docker-ujoj. Ĉi tio estas necesa por prepari la aplikaĵon por funkcii en la Kubernetes-grupo.

Docker-ujoj

Kubernetoj estas sistemo por aŭtomatigi la deplojon, skalo kaj administrado de konteneritaj aplikoj. Ĝi ankaŭ estas nomita "ujo orkestranto". Se Kubernetes funkcias kun ujoj, tiam antaŭ ol uzi ĉi tiun sistemon, ni unue devas akiri ĉi tiujn ujojn. Sed unue, ni parolu pri kio estas ujoj. Eble la plej bona respondo al la demando pri kio ĝi estas troveblas dokumentado al Docker:

Kontenera bildo estas malpeza, memstara, plenumebla pakaĵo, kiu enhavas aplikaĵon, kiu inkluzivas ĉion necesan por funkcii ĝin: aplikaĵokodo, rultempa medio, sistemaj iloj kaj bibliotekoj, agordoj. Utenitaj programoj povas esti uzataj en kaj Linukso kaj Vindoza medioj kaj ĉiam funkcios same sendepende de la infrastrukturo.

Ĉi tio signifas, ke ujoj povas ruliĝi sur ajna komputilo, inkluzive de produktaj serviloj, kaj en iu ajn medio, la aplikaĵoj enfermitaj en ili funkcios same.

Por esplori la funkciojn de ujoj kaj kompari ilin kun aliaj manieroj ruli aplikaĵojn, ni rigardu la ekzemplon de servado de React-aplikaĵo per virtuala maŝino kaj ujo.

▍Servi senmovajn dosierojn de React-aplikaĵo uzante virtualan maŝinon

Provante organizi la prizorgadon de statikaj dosieroj per virtualaj maŝinoj, ni renkontos la jenajn malavantaĝojn:

Malefika uzo de rimedoj, ĉar ĉiu virtuala maŝino estas kompleta operaciumo.
Platformdependeco. Kio funkcias en iu loka komputilo, eble ne funkcias ĉe produktservilo.
Malrapida kaj rimeda intensiva skalado de virtuala maŝina solvo.

Nginx-retservilo servanta senmovajn dosierojn kurantajn en virtuala maŝino

Se ujoj estas uzataj por solvi similan problemon, tiam, kompare kun virtualaj maŝinoj, oni povas rimarki la jenajn fortojn:

Efika uzo de rimedoj: laboru kun la operaciumo uzante Docker.
Platforma sendependeco. Ujo, kiun programisto povas funkcii per sia propra komputilo, funkcios ie ajn.
Malpeza deplojo per la uzo de bildaj tavoloj.

Nginx-retservilo servanta senmovajn dosierojn kurantajn en ujo

Ni komparis virtualajn maŝinojn kaj ujojn nur pri kelkaj punktoj, sed eĉ tio sufiĉas por senti la fortojn de ujoj. estas Vi povas trovi detalojn pri Docker-ujoj.

▍Konstruado de ujbildo por React-apo

La baza konstrubriketo de Docker-ujo estas la dosiero Dockerfile. Komence de ĉi tiu dosiero, baza bildo de la ujo estas registrita, tiam sekvenco de instrukcioj estas inkluzivita indikante kiel krei ujon, kiu renkontos la bezonojn de aplikaĵo.

Antaŭ ol ni komencas labori kun la dosiero Dockerfile, memoru, kion ni faris por prepari la dosierojn de la aplikaĵo React por alŝuti al la servilo Nginx:

Konstruante pakaĵon de la aplikaĵo React (npm run build).
Lanĉante la Nginx-servilon.
Kopiante la enhavon de dosierujo build el projekta dosierujo sa-frontend al la servila dosierujo nginx/html.

Malsupre vi povas vidi la paralelojn inter kreado de ujo kaj la supraj agoj faritaj sur la loka komputilo.

▍Preparante Dockerfile por la SA-Frontend-Apliko

Instrukcioj inkluditaj en Dockerfile por apliko SA-Frontend, konsistas el nur du teamoj. La fakto estas, ke la teamo de disvolviĝo de Nginx preparis bazan bildo por Nginx, kiun ni uzos por konstrui nian bildon. Jen la du paŝoj, kiujn ni devas priskribi:

Vi devas fari la bildon de Nginx la bazo de la bildo.
Dosierujo enhavo sa-frontend/build bezonas kopii al la bilda dosierujo nginx/html.

Se ni iras de ĉi tiu priskribo al la dosiero Dockerfile, tiam ĝi aspektos jene:

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

Kiel vi povas vidi, ĉio ĉi tie estas tre simpla, dum la enhavo de la dosiero eĉ rezultas sufiĉe legebla kaj komprenebla. Ĉi tiu dosiero diras al la sistemo preni la bildon nginx kun ĉio, kion ĝi jam havas, kaj kopiu la enhavon de la dosierujo build al la dosierujo nginx/html.

Ĉi tie vi eble havas demandon pri kiel mi scias, kie ĝuste kopii la dosierojn el la dosierujo build, t.e. de kie venis la vojo /usr/share/nginx/html. Fakte, ankaŭ ĉi tie estas nenio komplika. La fakto estas, ke la koncernaj informoj troveblas en Priskribo bildo.

▍ Kunmeti la bildon kaj alŝuti ĝin al la deponejo

Antaŭ ol ni povas labori kun kompletigita bildo, ni devas sendi ĝin al la bilddeponejo. Por fari tion, ni uzos la senpagan nub-bazitan bild-gastigan platformon Docker Hub. En ĉi tiu etapo de laboro, vi devas fari la jenon:

Instali Docker.
Registriĝi ĉe la retejo de Docker Hub.
Ensalutu al via konto per la sekva komando en la terminalo:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Nun vi bezonas, uzante la terminalon, iri al la dosierujo sa-frontend kaj rulu la jenan komandon tie:

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

Ĉi tie kaj sube en similaj komandoj $DOCKER_USER_ID devus esti anstataŭigita per via uzantnomo sur Docker Hub. Ekzemple, ĉi tiu parto de la komando povus aspekti jene: rinormaloku/sentiment-analysis-frontend.

En ĉi tiu kazo, ĉi tiu komando povas esti mallongigita per forigo de ĝi -f Dockerfile, ĉar la dosierujo en kiu ni ekzekutas ĉi tiun komandon jam havas ĉi tiun dosieron.

Por sendi la finitan bildon al la deponejo, ni bezonas la jenan komandon:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Post kompletigi ĝin, kontrolu vian liston de deponejoj sur Docker Hub por vidi ĉu la bildo estis sukcese puŝita al la nuba stokado.

▍Komencante ujon

Nun iu ajn povas elŝuti kaj ruli la bildon konatan kiel $DOCKER_USER_ID/sentiment-analysis-frontend. Por fari tion, vi devas ruli la sekvan sinsekvon de komandoj:

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

Nun la ujo funkcias, kaj ni povas daŭrigi labori kreante aliajn bildojn, kiujn ni bezonas. Sed antaŭ ol ni daŭrigu, ni komprenu la dezajnon 80:80, kiu troviĝas en la komando por ruli la bildon kaj povas ŝajni konfuza.

Unua numero 80 estas la havennumero de la gastiganto (tio estas la loka komputilo).
Dua numero 80 estas la haveno de la ujo al kiu la peto estu redirektita.

Konsideru la sekvan ilustradon.

Havena plusendado

La sistemo plusendas petojn de la haveno <hostPort> al la haveno <containerPort>. Tio estas, aliri la havenon 80 komputilo estas alidirektita al haveno 80 ujo.

Ekde la haveno 80 malfermita sur la loka komputilo, vi povas aliri la aplikaĵon de ĉi tiu komputilo ĉe localhost:80. Se via sistemo ne subtenas Docker, vi povas ruli la aplikaĵon sur Docker virtuala maŝino, kies adreso aspektos kiel <docker-machine ip>:80. Por ekscii la IP-adreson de la virtuala maŝino Docker, vi povas uzi la komandon docker-machine ip.

Je ĉi tiu punkto, post kiam la antaŭa aplika ujo sukcese lanĉita, vi devus povi malfermi ĝian paĝon en retumilo.

▍.dockerignore dosiero

Konstruado de la aplika bildo SA-Frontend, ni povus rimarki, ke ĉi tiu procezo estas ege malrapida. Ĉi tio estas ĉar la bildkonstrua kunteksto devas esti sendita al la Docker-demono. La dosierujo kiu reprezentas la konstruan kuntekston estas donita kiel la lasta argumento al la komando docker build. En nia kazo, estas punkto ĉe la fino de ĉi tiu komando. Ĉi tio rezultigas la sekvan strukturon inkluzivita en la kunteksto kunteksto:

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

Sed el ĉiuj dosierujoj ĉi tie, ni bezonas nur dosierujon build. Elŝuti ion alian estas tempoperdo. Vi povas akceli la konstruon dirante al Docker kiujn dosierujojn ignori. Por fari tion, ni bezonas dosieron .dockerignore. Vi, se vi konas la dosieron .gitignore, la strukturo de ĉi tiu dosiero verŝajne aspektos konata. Ĝi listigas dosierujojn, kiujn la bildkonstrua sistemo povas ignori. En nia kazo, la enhavo de ĉi tiu dosiero aspektas jene:

node_modules
src
public

dosiero .dockerignore devas esti en la sama dosierujo kiel la dosiero Dockerfile. Nun la muntado de la bildo daŭros kelkajn sekundojn.

Ni traktu nun la bildon por Java aplikaĵo.

▍Konstruado de ujo-bildo por Java-aplikaĵo

Vi scias kion, kaj vi jam lernis ĉion, kion vi bezonas por krei ujajn bildojn. Tial ĉi tiu sekcio estos tre mallonga.

Malfermu la dosieron Dockerfile, kiu troviĝas en la projekta dosierujo sa-webapp. Se vi legas la tekston de ĉi tiu dosiero, tiam en ĝi vi renkontos nur du novajn konstruojn, kiuj komenciĝas per ŝlosilvortoj ENV и EXPOSE:

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

Ŝlosilvorto ENV permesas vin deklari mediajn variablojn ene de Docker-ujoj. Precipe, en nia kazo, ĝi ebligas al vi agordi URL por aliri la API de la aplikaĵo, kiu faras tekstan analizon.

Ŝlosilvorto EXPOSE permesas vin diri al Docker malfermi havenon. Ni uzos ĉi tiun havenon dum ni laboras kun la aplikaĵo. Ĉi tie vi povas vidi tion en Dockerfile por apliko SA-Frontend tia komando ne ekzistas. Ĉi tio estas nur por dokumentado, alivorte, ĉi tiu konstruo estas por la leganto Dockerfile.

Konstrui la bildon kaj puŝi ĝin al la deponejo aspektas ekzakte kiel la antaŭa ekzemplo. Se vi ankoraŭ ne tre certas pri viaj kapabloj, la respondaj komandoj troviĝas en la dosiero README.md en dosierujo sa-webapp.

▍Konstrui ujan bildon por Python-aplikaĵo

Se vi rigardas la enhavon de la dosiero Dockerfile en dosierujo sa-logicvi ne trovos ion novan tie. La komandoj por konstrui la bildon kaj puŝi ĝin al la deponejo ankaŭ devus esti konataj al vi, sed, kiel estas la kazo kun niaj aliaj aplikaĵoj, ili troveblas en la dosiero. README.md en dosierujo sa-logic.

▍Testado de konteneritaj aplikoj

Ĉu vi povas fidi ion, kion vi ne testis? Ankaŭ mi ne povas. Ni provu niajn ujojn.

Ni komencu la aplikaĵujon sa-logic kaj agordu ĝin por aŭskulti en haveno 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Ni komencu la aplikaĵujon sa-webapp kaj agordu ĝin por aŭskulti en haveno 8080. Krome, ni devas agordi la havenon, sur kiu la Python-apliko aŭskultos petojn de la Java-apliko reasignante la mediovariablon. 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
```

Por lerni kiel eltrovi la IP-adreson de ujo aŭ Docker VM, raportu la dosieron Legu.

Ni komencu la aplikaĵujon sa-frontend:

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

Nun ĉio estas preta por navigi en la retumilo al la adreso localhost:80 kaj provu la apon.

Bonvolu noti, ke se vi ŝanĝas la havenon por sa-webapp, aŭ se vi funkcias Docker VM, vi devos redakti la dosieron App.js el dosierujo sa-frontendŝanĝante la IP-adreson aŭ havenon en la metodo analyzeSentence()anstataŭigante aktualajn informojn anstataŭ malnoviĝintajn datumojn. Post tio, vi devas rekunmeti la bildon kaj uzi ĝin.

Jen kiel nia aplika diagramo aspektas nun.

Mikroservoj funkcias en ujoj

Resumo: kial ni bezonas Kubernetes-grupon?

Ni ĵus reviziis la dosierojn Dockerfile, parolis pri kiel konstrui bildojn kaj puŝi ilin al Docker-deponejo. Krome, ni lernis kiel akceli la muntadon de bildoj uzante la dosieron .dockerignore. Kiel rezulto, niaj mikroservoj nun funkcias en Docker-ujoj. Ĉi tie vi eble havas tute pravigitan demandon pri kial ni bezonas Kubernetes. La respondo al ĉi tiu demando estos dediĉita al la dua parto de ĉi tiu materialo. Dume, konsideru la jenan demandon:
Ni supozu, ke nia tekst-analiza TTT-aplikaĵo populariĝis tutmonde. Milionoj da petoj venas al li ĉiuminute. Ĉi tio signifas ke mikroservoj sa-webapp и sa-logic estos sub grandega streĉo. Kiel grimpi ujojn kurantajn mikroservojn?

fonto: www.habr.com

Kubernetes Tutorial Parto 1: Aplikoj, Mikroservoj kaj Ujoj