Kubernetes Tutorialis Pars I: Applications, Microservices et Containers

Rogantibus nostris, Habr hub created creavit Kubernetes et primam editionem in ea collocare dignamur. Subscribe!

Kubernetes facilis est. Cur ripae mihi multam pecuniam dant ad operandum in hac provincia, cum quis paucis horis hanc technologiam domare potest?

Si dubitas Kubernetes tam cito posse disci, moneo te ipsum facere conari. Nempe, hanc materiam domitam, applicationem ex microservices in botro Kubernetes currere poteris. Hoc praestare possum, quia in eadem methodo, qua hic utor, doceo clientes nostros laborare cum Kubernetibus. Quid facit hic dux ab aliis diversus? Nam mattis. Pleraque igitur harum materiarum simplicium explicatione incipiunt - conceptus Kubernetes et lineamenta imperii kubectl. Auctores horum articulorum assumunt lectorem eorum nota applicationis evolutionis, microservices, et vasis Docker. Ibimus alio modo. Primum, fama quomodo applicationem microservices in computatrale currendum est. Tunc imagines vasis singulis microserviis construere videbimus. Et postea cognoscemus Kubernetes et instruere applicationem applicationis microservices in botro a Kubernetes tractatam resolvere.

Hic aditus, gradatim accessus ad Kubernetes, profunditatem dabit intellegendi rerum eventuum quod homo mediocris indiget ad intellegendum quomodo simpliciter omnia in Kubernetes sint ordinata. Kubernetes technologiam simplex certe est, dummodo qui velit dominari, sciat ubi et quomodo adhibetur.

Nunc, sine ulteriori cura, ad opus et loqui de applicatione operam dabimus.

Experimentalis app

Applicatio nostra unum tantum munus faciet. Adhibet, ut input, unam sententiam, qua, adhibitis instrumentis analysi textibus, analysin sensus facit huius sententiae, obtinens aestimationem motus animi auctoris sententiae ad aliquod obiectum.

Haec fenestra principalis huius applicationis similis est.

Sententia Analysis Web Application

Ex parte technicis applicatio consistit in tribus micromissionibus, quarum unaquaeque certos munerum certos solvit;

• SA-Frontend est servo interretiali Nginx qui files React static servit.
• SA-WebApp applicatio interretialis in Java scripta est quae petitiones a fronte tractat.
• SA-Logica est applicatio Pythonis quae analysin textus sensui praestat.

Gravis est notare microservices non separatim inesse. Ideam "separationis officiorum" efficiunt, sed simul inter se mutuae necessitati sunt.

Data fluit in applicatione

In superiore schemate, gradus numerales rationes videre potes, notitia illustrans in applicatione fluit. Dirumpamus eos;

1. Navicula lima a servo petit index.html (quod rursus onerat React sarcina app).
2. Usor mutuatur cum applicatione, hoc causat vocationem ad applicationem interretialem secundum fontem.
3. Applicatio interretialem rogat ut Pythone textum ad partem applicando promoveat.
4. Python applicatio sensum textus resolvit et exitum reddit tamquam responsio ad petitionem.
5. Ver applicatio responsionem mittit ad applicationem React (quod vicissim ostendit exitum textus parsed ad utentis).

Ad has omnes applicationes in codice inveniri possunt hic. Suadeo ut hoc repositorium tibi nunc exscribas, cum multa experimenta iucunda sint cum eo ante nos.

Currentem applicationem microservices secundum apparatus loci in

Ut applicationis ad operandum, tria microservices omnes incipere oportet. Pulcherrima earum initium sit - ante finem applicationis.

Profecti sunt reagunt loci progressionem

Ut ad applicationem React currere, Node.js compagem ac NPM in computatrum tuum instituere debes. Post haec omnia instituis, utere termino ad documentum folder sa-frontend et percurre mandatum hoc;

npm install

Exsequendo praeceptum folder node_modules dependentiae applicationis React onerentur, quarum monumenta in tabella package.json. Post demptionem clientelae in eodem folder, sequens mandatum currite:

npm start

Id omne. App React nunc currit et adiri potest navigando ad inscriptionem navigandi localhost:3000. Aliquid in suo codice mutare potes. Statim effectum harum mutationum in navigatro videbis. Hoc fieri potest propter modulorum substitutionem "calidum" sic dictum. Propter hoc, ante-finis progressus in simplicem et iucundam experientiam vertit.

Praeparans React app productio

Ad proposita actualiter appli React utendi, necesse est ut eam in staticorum imaginum convertat et serviat clientibus utens interretiali.

Ad app aedificare React, terminatio iterum utens, ad folder navigare sa-frontend et percurre mandatum hoc;

npm run build

Hoc creabit directorium in project folder build. Omnes ordines statices continebit ad applicationem React ad operandum requisita.

Serviens stabilis files cum Nginx

Primum debes instituere ac persequi Nginx interretialem server. est illud exsequi potes et instructiones invenire pro instituendo et currendo. Tunc debes effingo contenta folder sa-frontend/build ut folder [your_nginx_installation_dir]/html.

Cum hoc accessu, tabella generata in applicatione conventus React index.html erit praesto ad [your_nginx_installation_dir]/html/index.html. Haec est tabella quae, per defaltam, servo Nginx exit cum ea accessu. Servo configuratur audire in portum 80, sed morem facere potes ut tabellam emendo [your_nginx_installation_dir]/conf/nginx.conf.

Nunc navigatrum aperi et vade ad localhost:80. Videbis paginam React app.

React app serviens Nginx servo

Si nunc aliquid in agro Type your sentence ac premere puga Send — nihil fiet. Sed, si consolem spectes, erroris nuntios ibi videre potes. Ut exacte intelligamus ubi hi errores inveniunt, applicationem codicis excutiamus.

Analysis in codice ante finem application

Vultus in codice tabellae App.js, videre possumus quod strepitando in puga Send vocat modum analyzeSentence(). Codex huius methodi infra ostenditur. Simul hoc attende quod ad singulas lineas quibus est commentarium formae # Номерexstat expositio infra codicem. Ad eundem modum alia codicis parse dabimus fragmenta.

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. Domicilium cui POSTULATUM petitur. Haec oratio ponitur ut application exspectans petitiones earum.

2.Petitio corporis missis ad applicationem. Hic est exemplum petitio corporis;

{
    sentence: "I like yogobella!"
}

3.Cum responsio ad petitionem recipitur, status componentis renovatus est. Hoc efficit ut re- reddant. Si datam accipimus (id est, obiectum JSON continens notitias ingressas et textum computatum score), componentem faciemus output Polaritydum condiciones occurrant. Hic est quomodo componentium describemus:

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

In codice satis bene operari videtur. Quid hic mali usquam? Si ponatur in oratione ad quam applicatio postulationem tabellariorum mittere conatur, nihil tamen est quod hanc petitionem admittere ac processum esse possit, tunc eris rectissime. Scilicet ut processus petitiones ad electronicam accedentes http://localhost:8080/sentimentnecesse est ut ad applicationem interretialem curramus quae in Ver.

We need a Spring application that can take a POST request

-Prorexerant telam applicationem secundum Spring

Ad applicationem fontis explicandam, JDK8 et Maven opus est ac variabilium ambitum apte conformatus. Postquam haec omnia inaugurare, pergere potes in consilio nostro.

Packing application in vas file

Navigare, terminatio utens, ad folder sa-webapp et intrant per hoc mandatum;

mvn install

Post hoc praeceptum folder sa-webapp Directory erit creatus target. Hoc est ubi applicatio Javae collocabitur, in vase fictili, quod per tabella repraesentatum est sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

Deductis a Java Application

Ad folder target et currunt applicatione cum hoc imperio;

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

Occurret error in exequendo hoc praeceptum. Ut eam defigendo incipiamus, singulas exceptiones in ACERVUS notarum notarum parse possumus:

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

Nobis, maximi momenti hic est mentio impossibilitatis declarandi sensus sa.logic.api.url. Analyze codicem ubi error incidit.

Java application codice analysis

Hic est codex PRAECISIO ubi error occurrit.

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

1. In SentimentController est ager saLogicApiUrl. Pretium eius a proprietate positum est sa.logic.api.url.
2. Linea saLogicApiUrl concatenatus cum valore /analyse/sentiment. Una oratio formant vocationem ad microserviam faciendam quae analysim textui praestat.

-Ponere proprietas valorem

Vere, fons defectus bonorum bonorum fasciculus est application.propertiesquae inveniri potest at sa-webapp/src/main/resources. Utens autem non est solum modus ad bona bona disponenda. Hoc etiam facere potes cum mandato sequenti;

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

Valor huius proprietatis debet electronicam ostendere nostri Pythonis applicationis.

Configurando eam dicimus applicationis ver interreti ubi opus est ut ad petitiones parsing textus exequatur.

Ut vitas nostras non inpediam, Python applicationes in promptu habebimus localhost:5000 et de hoc experiri non obliviscar. Quam ob rem mandatum ut applicationis fontis incipiatur, hoc erit simile:

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

Nostra ratio deest Pythonis applicationis

Nunc iustus ad cursum Pythonis applicationis et ratio operis expectata erit.

Profecta Pythone application

Ad applicationem Python currendum, Python 3 et Pip inauguratus habere debetis, et aptas variabiles ambitus recte positos habere debetis.

Install clientelae

Ad proiicere folder sa-logic/sa ac percurrunt imperata;

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

App Lorem

Cum clientelis inauguratis, parati sumus applicationes ad currendum:

python sentiment_analysis.py

Hoc mandato facto, sequentia dicentur;

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

Hoc significat applicationem currit et postulata exspectans localhost:5000/

Code investigationis

Intueamur Pythonem codicem schedulam ad intellegendum quomodo petitionibus respondeat:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

1. Object initialization Flask.
2. Specificare inscriptione pro petitione facienda.
3. Retrieving possessionem sentence ab instantia corporis.
4. Anonymous object initialization TextBlob et questus ad valorem polarity Prima propositio recepta est in corpore petitionis (in nostro casu, haec sola propositio pro analysi submissa).
5. Reversi responsio, corpus cuius textus oblationis continet et index pro eo computatur polarity.
6. Laxam applicationis deducendo, quae in promptu erunt 0.0.0.0:5000 (Potes etiam accedere ad constructionem formae utens localhost:5000).

Nunc a ligula id elit cursus efficitur. Inter se correspondent. Haec est applicatio schematis quod in hac operis stadio apparet.

Omnia microservices quae applicationes faciunt ad statum sanum perducuntur

Nunc, antequam pergamus, app React aperi in navigatro et conantur ut sententiam aliquam cum eo dividere. Si omnia recte fiunt - urgente puga Send proventus analysi sub arca archa videbis.

In sequenti sectione, loquemur quomodo ad nostras micro-ices in Docker vasis currendum est. Hoc necessarium est ut applicationes ad botrum in Kubernetes currendum apparandae sint.

Docker continentia

Kubernetes est ratio automandi instruere, scandere et administratio applicationum continens. Dicitur etiam "orchestrator continens". Si Kubernetes cum vasis operatur, tum antequam hoc systemate utendo, primum haec continentia acquirere oportet. Sed primum de vasis quae sint fama. Fortasse optime respondetur ad quaestionem de qua in re inveniri potest documentum ad Docker:

Imago continentis est fasciculus levis, sui iuris, et exsecubilis, continens applicationem quae omnia necessaria ad eam currendam includit: codicem applicationis, ambitum executionis, instrumenta et bibliothecas systematis, et configurationes. Programmata continentia in ambitibus adhiberi possunt... Linux и Windows, et semper eodem modo operabuntur, infrastructura non obstante.

Hoc significat vasa quaelibet computatralia, inclusa servientibus productivis, et in ambitu cuiuslibet decurrere possunt, applicationes in eis inclusae eodem modo operabuntur.

Ad lineamenta vasorum explorandum et ad alias vias applicationes ad currendum comparandas, exemplum inspiciamus applicatio applicatio React serviendi virtualis machinae et vase utendi.

Serving static files de React applicationem uti virtualis apparatus

Conamur ad sustentationem imaginum staticarum utentes virtualis machinis, sequentibus incommodis occurremus:

1. Inefficax usus facultatum, quia unaquaeque machina virtualis est ratio operativa perfecta.
2. Rosci dependentia. Quae in aliquo computatorio locali operatur, bene operari in servo productionis non potest.
3. Tarda et intensiva intensiva scalae virtualis machinae solutionis.

Nginx servo telae servientes statice currit in machinae virtualis

Si continentia ad similem problema solvendum adhibita, in comparatione cum machinis virtualibus, vires sequentes notari possunt;

1. Faciens usus opum: labor cum systemate operante utens Docker.
2. Rosci libertatem. Continens quem elit in computatro suo currere potest alicubi currere.
3. Instruere leve pondus imaginis usum per stratis.

Nginx serviens telae static servientes currit in vase

Machinationes virtuales et continentia in paucis punctis tantum comparavimus, sed etiam hoc satis est ad vires continentiae percipere. est Singula de vasis Docker invenire potes.

Aedificium continens imaginem react app

In basic aedificium obstructionum de Docker continens tabella Dockerfile. Principio huius fasciculi, basis imago continentis commemoratur, deinde ordo praeceptorum includitur ostendens quomodo vas creet qui applicationis necessitates occurret.

Antequam incipit opus cum tabella Dockerfilememento quid fecerimus ut tabulas applicationis React praeparandae ad Nginx servo uploading:

1. Ad aedificationem React app sarcina (npm run build).
2. Satus Nginx servo.
3. Effingo contenta directorium build de project folder sa-frontend in calculonis servi folder nginx/html.

Infra videre potes parallelas inter continens creando et actiones superius in computatro locali factas.

Praeparans Dockerfile ad SA-Frontend Application

Instructiones ut includantur Dockerfile per applicationem SA-Frontendex duobus tantum iugis. Re vera Nginx turmas evolutionis fundamentales paravit imagini ad Nginx, qua ad imaginem nostram fabricandam utemur. Hic sunt duo gradus describere;

1. Nginx imago fundamentum imaginis efficere debes.
2. Folder content sa-frontend/build opus est ut effingo imaginem folder nginx/html.

Si ex hac tabella ad descriptionem ibimus Dockerfileerit, sic videbimus;

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

Ut videre potes, omnia hic valde simplicia sunt, dum contenta tabella eveniunt ut admodum lectu et intellectu sint. Haec lima ratio ut imaginem narrat nginx cum omnibus, quae iam possidet, ac contenta in indicem exscribere build ad indicem nginx/html.

Hic interrogare potes de quo scio ubinam limas e folderm exacte effingas build, i.e /usr/share/nginx/html. Nam vel turpis nulla. Ita est quod notitias talium reperiri possunt descriptio imaginem.

-Congregans imaginem et imposuisti in conditorio

Antequam ad imaginem perfectam operari possumus, repositorium imagini submittere necesse est. Ad hoc utemur libero nubilo-substructio imaginis suggestae Docker Hub obnoxiae. In hac operis stadio, sequentia facere debes;

1. statuam Docker.
2. Subcriptio in situ Docker Hub.
3. Log in rationem vestram per currit hoc mandatum in termino:

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

Nunc opus est utens terminali, vade ad indicem sa-frontend et percurre hoc mandatum ibi.

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

Hic et infra in similibus mandatis $DOCKER_USER_ID reponi debet cum usoris tui in Docker Hub. Ut haec pars imperii viderem sic; rinormaloku/sentiment-analysis-frontend.

Hoc in casu, hoc mandatum minui potest ab eo removendo -f Dockerfilequoniam folder in quo hoc praeceptum exequimur iam hunc fasciculum habet.

Ut imaginem perfectam mittas in repositorio, hoc praecepto opus est:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Hoc perfecit, repositoria in Docker Hub inspicias indicem tuum ut videas an imago bene reposita fuerit ad nubem reposita.

Satus vas

Nunc quis excipere et currere potest ut notum sit $DOCKER_USER_ID/sentiment-analysis-frontend. Ut hoc facias, sequenti mandatorum ordine debes currere;

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

Continens nunc currit, et operari pergere possumus alias imagines quae opus sunt creando. Sed antequam pergamus, consilium intellegamus 80:80quae est in praecepto imago et confusio.

• Primus numerus 80 numerus portus exercitus (id est computatorii localis).
• Secundus numerus 80 portus est continens, ad quod petitio determinanda est.

Hanc illustrationem considera.

Portus Transmissio

Ratio procedit a portu petit <hostPort> ad portum <containerPort>. Id est, accessus portus 80 computatrum determinatur ad portum 80 continens.

Cum portum 80 aperitur in computatro locali, applicationem ex hoc computatrum at accedere potes localhost:80. Si ratio tua Docker non sustinet, applicationem in Docker apparatus virtualis currere potes, cuius oratio tamquam <docker-machine ip>:80. Invenire IP oratio Docker machinae virtualis, imperio uti potes docker-machine ip.

Hic, cum accessus ad finem app continens feliciter emissus est, paginam suam in navigatro aperire possis.

.dockerignore file

Aedificationem application imaginem SA-Frontendprocessus lentissimus hic animadvertere potuimus. Hoc est, quia imago fabricandi contextus Docker daemoni mitti debet. Directorium repraesentans contextum constructum pro ultimo argumento ad mandatum datum est docker build. In nobis, in fine huius praecepti punctum est. Id evenit ut sequenti structura in contextu conventus comprehendatur:

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

Sed inter omnes folders qui hic adsunt, solum folder egent build. Download aliud est superfluum. Potes accelerare fabricam narrando Docker quae directoria ignorare. Ut hoc faciamus, lima opus est .dockerignore. Tu, si nota tabella .gitignore, structura huius fasciculi nota verisimiliter inspiciet. Directoria recenset quos ratio aedificandi imaginis ignorare potest. In casu nostro, contenta huius fasciculi sic habent speciem:

node_modules
src
public

lima .dockerignore debet esse in eodem folder ut lima Dockerfile. Nunc conventus statuae paucis secundis accipies.

Nunc agamus de imagine applicationis Javae.

Aedificium vas imaginis pro Java application

Scis quid, et iam omnia didicisti quae debes facere continens imagines. quam ob rem hoc capitulum brevissimum erit.

Aperi tabella Dockerfile, quae sita est in documento folder sa-webapp. Si textum huius fasciculi legas, in eo invenies duas tantum constructiones novas quae ab keywords incipiunt ENV и EXPOSE:

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

keyword ENV sino vos declarare variabiles ambitus intra Docker continentia. Praesertim in casu nostro, te permittit ut Domicilium accedas ad API applicationis quae analysin textus perficit.

keyword EXPOSE Docker narrare te permittit ut portum aperiat. Hoc portu utimur ut cum applicatione laboramus. Hic videre potes quod in Dockerfile per applicationem SA-Frontend tale mandatum non est. Haec ad documentorum proposita tantum, aliis verbis, haec constructio ad lectorem pertinet Dockerfile.

Aedificans imaginem et impellens ad repositio spectat prorsus sicut exemplum praecedentem. Si nondum valde confidis in viribus tuis, mandata debita in tabella reperiri possunt README.md in folder sa-webapp.

Aedificans Python imaginem continens application

Si vide documenta contenta Dockerfile in folder sa-logicnihil novi ibi reperies. Mandata ad imaginem construendam et ad repositorium impellentem familiaria tibi iam esse debent, sed, sicut in aliis applicationibus nostris, in tabella inveniri possunt. README.md in folder sa-logic.

Testing vasis applications

Potesne credere aliquid quod non tentasti? Non possum etiam. Nostra vasa experiamur.

1. Sit scriptor satus applicationis continens sa-logic et configurare eam audire in portum 5050:

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

2. Sit scriptor satus applicationis continens sa-webapp et configurare eam audire in portum 8080. Praeterea portum apponere oportet quem applicatio Python petita a Java applicatione audiet, reposito ambitus variabilis. 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

Ut scias quomodo invenias inscriptionem IP continentis vel Docker VM, refer ad documentum README.

Sit scriptor satus applicationis continens sa-frontend:

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

Nunc omnia parata sunt ut in navigatro ad electronicam navigant localhost:80 et probate app.

Nota quaeso quod si mutare portum for sa-webappaut si curris Docker VM, tabellam emendare debes App.js ex folder sa-frontendmutato IP oratio aut portum numerum in modum analyzeSentence()substituendo current notitia pro obsoleta notitia. Deinde, imago coeundi debes et utere.

Haec nostra applicationis tabula similis nunc spectat.

Microservices currunt in vasis

Summarium: cur botrum Kubernetes indigemus?

Nos iustus files recensuit Dockerfilenarraverunt quomodo imagines aedificare et repositorium pellere Docker. Praeterea didicimus conventum imaginum accelerare tabellae utentes .dockerignore. Quam ob rem microservices nostra nunc in vasis Docker currunt. Hic fortasse iustissime quaestionem habere potest cur Kubernetes indigeamus. Respondetur huic quaestioni in secunda parte huius materiae. Interim considera istam quaestionem;
Demus nobis analysin textus analysin interretialem applicationem facta populari per orbem terrarum. Ingentium petitionum minutatim ad eum perveniunt. Id quod microservices sa-webapp и sa-logic erit ingentes accentus. Quomodo vasa scandere quae microservices currunt?

Source: www.habr.com