Tutorial sa Kubernetes Part 1: Mga Application, Microservice, at Container

Sa aming kahilingan, gumawa si Habr ng hub Kubernetes at nalulugod kaming ilagay ang unang publikasyon dito. Mag-subscribe!

Madali lang ang Kubernetes. Bakit binabayaran ako ng mga bangko ng maraming pera upang magtrabaho sa lugar na ito, habang kahit sino ay maaaring makabisado ang teknolohiyang ito sa loob lamang ng ilang oras?

Kung nagdududa ka na mabilis matutunan ang Kubernetes, iminumungkahi kong subukan mo ito mismo. Ibig sabihin, kapag pinagkadalubhasaan ang materyal na ito, magagawa mong magpatakbo ng isang application batay sa mga microservice sa isang cluster ng Kubernetes. Masisiguro ko ito, dahil ito mismo ang parehong pamamaraan na ginamit dito na tinuturuan ko ang aming mga kliyente na makipagtulungan sa Kubernetes. Ano ang pagkakaiba ng gabay na ito sa iba? Sa katunayan, mayroong maraming mga bagay. Kaya, karamihan sa mga materyal na ito ay nagsisimula sa isang paliwanag ng mga simpleng bagay - ang mga konsepto ng Kubernetes at ang mga tampok ng kubectl command. Ipinapalagay ng mga may-akda ng mga materyal na ito na pamilyar ang kanilang mga mambabasa sa pagbuo ng application, mga microservice, at mga container ng Docker. Pupunta tayo sa kabilang daan. Una, pag-uusapan natin kung paano magpatakbo ng isang application batay sa mga microservice sa isang computer. Pagkatapos ay titingnan natin ang pagbuo ng mga imahe ng lalagyan para sa bawat microservice. At pagkatapos nito, makikilala natin ang Kubernetes at titingnan ang pag-deploy ng application batay sa mga microservice sa isang cluster na pinamamahalaan ng Kubernetes.

Ang diskarte na ito, na may unti-unting diskarte sa Kubernetes, ay magbibigay ng lalim ng pag-unawa sa kung ano ang nangyayari na kinakailangan para sa karaniwang tao upang maunawaan kung gaano kasimpleng gumagana ang lahat sa Kubernetes. Ang Kubernetes ay tiyak na isang simpleng teknolohiya, kung alam ng mga gustong matutunan ito kung saan at paano ito ginagamit.

Ngayon, nang walang karagdagang ado, magsimula tayo at pag-usapan ang tungkol sa application na gagawin natin.

Pang-eksperimentong aplikasyon

Isang function lang ang gagawin ng aming application. Kinakailangan ang isang pangungusap bilang input, pagkatapos nito, gamit ang mga tool sa pagsusuri ng teksto, nagsasagawa ito ng pagsusuri ng damdamin ng pangungusap na ito, na nakakakuha ng pagtatasa ng emosyonal na saloobin ng may-akda ng pangungusap sa isang tiyak na bagay.

Ito ang hitsura ng pangunahing window ng application na ito.

Web application para sa pagsusuri ng damdamin ng mga teksto

Mula sa isang teknikal na punto ng view, ang application ay binubuo ng tatlong microservices, ang bawat isa ay malulutas ang isang tiyak na hanay ng mga problema:

• Ang SA-Frontend ay isang Nginx web server na naghahain ng mga static na React file.
• Ang SA-WebApp ay isang web application na nakasulat sa Java na nagpoproseso ng mga kahilingan mula sa frontend.
• Ang SA-Logic ay isang Python application na nagsasagawa ng pagsusuri ng damdamin sa teksto.

Mahalagang tandaan na ang mga microservice ay hindi umiiral nang nakahiwalay. Ipinapatupad nila ang ideya ng "paghihiwalay ng mga responsibilidad", ngunit sa parehong oras kailangan nilang makipag-ugnayan sa isa't isa.

Dumadaloy ang data sa application

Sa diagram sa itaas, makikita mo ang mga may bilang na yugto ng system, na naglalarawan ng mga daloy ng data sa application. Tingnan natin sila:

1. Ang browser ay humihiling ng isang file mula sa server index.html (na, sa turn, ay nagda-download ng React application package).
2. Nakikipag-ugnayan ang user sa application, nagiging sanhi ito ng isang tawag sa Spring-based na web application.
3. Ipinapasa ng web application ang kahilingan na magsagawa ng pagsusuri ng teksto sa Python application.
4. Ang Python application ay nagsasagawa ng pagsusuri ng damdamin ng teksto at ibinabalik ang resulta bilang tugon sa kahilingan.
5. Ang Spring application ay nagpapadala ng tugon sa React application (na, sa turn, ay nagpapakita ng resulta ng pagsusuri ng teksto sa user).

Ang code para sa lahat ng mga application na ito ay matatagpuan dito. Inirerekomenda ko na kopyahin mo ang repositoryo na ito para sa iyong sarili ngayon, dahil maraming mga kawili-wiling mga eksperimento dito sa unahan namin.

Pagpapatakbo ng isang microservice-based na application sa iyong lokal na makina

Upang gumana ang application, kailangan nating simulan ang lahat ng tatlong microservice. Magsimula tayo sa pinaka-cute sa kanilang lahat - ang front-end na application.

▍I-set up ang React para sa lokal na pag-unlad

Upang magpatakbo ng isang React na application, kailangan mong i-install ang Node.js platform at NPM sa iyong computer. Kapag na-install mo na ang lahat ng ito, gamitin ang terminal upang mag-navigate sa folder ng iyong proyekto sa-frontend at patakbuhin ang sumusunod na command:

npm install

Sa pamamagitan ng pagpapatakbo ng command na ito sa folder node_modules ang mga dependency ng React application ay mailo-load, ang mga tala nito ay nasa file package.json. Kapag na-download na ang mga dependency sa parehong folder, patakbuhin ang sumusunod na command:

npm start

Iyon lang. Ngayon ang React application ay tumatakbo, maaari mo itong ma-access sa pamamagitan ng pagpunta sa sumusunod na address sa iyong browser: localhost:3000. Maaari mong baguhin ang isang bagay sa code nito. Makikita mo kaagad ang epekto ng mga pagbabagong ito sa browser. Posible ito salamat sa tinatawag na "mainit" na kapalit ng mga module. Ginagawa nitong simple at kasiya-siyang karanasan ang front-end development.

▍Paghahanda ng React application para sa produksyon

Para sa layunin ng aktwal na paggamit ng isang React application, kailangan naming i-convert ito sa isang set ng mga static na file at ihatid ang mga ito sa mga kliyente gamit ang isang web server.

Upang buuin ang React application, gamit ang terminal, mag-navigate sa folder sa-frontend at patakbuhin ang sumusunod na command:

npm run build

Ito ay lilikha ng isang direktoryo sa folder ng proyekto build. Maglalaman ito ng lahat ng mga static na file na kinakailangan para gumana ang React application.

▍Paghahatid ng mga static na file gamit ang Nginx

Una kailangan mong i-install at patakbuhin ang Nginx web server. Dito maaari mong i-download ito at makahanap ng mga tagubilin kung paano i-install at patakbuhin ito. Pagkatapos ay kailangan mong kopyahin ang mga nilalaman ng folder sa-frontend/build sa folder [your_nginx_installation_dir]/html.

Sa diskarteng ito, ang file na nabuo sa panahon ng proseso ng pagbuo ng React application index.html ay makukuha sa [your_nginx_installation_dir]/html/index.html. Ito ang file na, bilang default, ginagawa ng Nginx server kapag ina-access ito. Ang server ay naka-configure upang makinig sa port 80, ngunit maaari itong i-customize sa paraang kailangan mo sa pamamagitan ng pag-edit ng file [your_nginx_installation_dir]/conf/nginx.conf.

Ngayon buksan ang iyong browser at pumunta sa localhost:80. Makikita mo ang pahina ng React application.

React application na inihatid ng Nginx server

Kung may ipinasok ka ngayon sa field Type your sentence at pindutin ang pindutan Send - walang mangyayari. Ngunit, kung titingnan mo ang console, makikita mo ang mga mensahe ng error doon. Upang maunawaan kung saan eksaktong nangyayari ang mga error na ito, suriin natin ang code ng application.

▍Pagsusuri ng code ng aplikasyon sa harap

Pagtingin sa file code App.js, makikita natin na ang pagpindot sa pindutan Send tinatawag na isang pamamaraan analyzeSentence(). Ang code para sa pamamaraang ito ay ibinigay sa ibaba. Pakitandaan na para sa bawat linya na may komento ng form # Номер, mayroong isang paliwanag na ibinigay sa ibaba ng code. Susuriin namin ang iba pang mga fragment ng code sa parehong paraan.

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. Ang URL kung saan ginawa ang kahilingan sa POST. Ipinapalagay na mayroong isang aplikasyon sa address na ito na umaasa sa mga naturang kahilingan.

2.Ang katawan ng kahilingan na ipinadala sa aplikasyon. Narito ang isang halimbawa ng katawan ng kahilingan:

{
    sentence: "I like yogobella!"
}

3.Kapag natanggap ang isang tugon sa isang kahilingan, ina-update ang estado ng bahagi. Nagiging sanhi ito ng muling pag-render ng bahagi. Kung nakatanggap kami ng data (iyon ay, isang JSON object na naglalaman ng data ng input at ang kinakalkula na marka ng teksto), ilalabas namin ang bahagi Polarity, dahil matutugunan ang mga naaangkop na kundisyon. Ganito namin inilalarawan ang bahagi:

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

Mukhang gumagana nang maayos ang code. Ano ang mali dito, gayon pa man? Kung ipagpalagay mo na sa address kung saan sinusubukan ng aplikasyon na magpadala ng isang kahilingan sa POST, wala pang maaaring tanggapin at iproseso ang kahilingang ito, kung gayon ikaw ay magiging ganap na tama. Ibig sabihin, upang iproseso ang mga kahilingang natanggap sa http://localhost:8080/sentiment, kailangan naming magpatakbo ng isang web application batay sa Spring.

Kailangan namin ng Spring application na maaaring tumanggap ng POST request

▍Pagse-set up ng Spring based na web application

Upang makapag-deploy ng Spring application, kakailanganin mo ang JDK8 at Maven at maayos na na-configure ang mga variable ng kapaligiran. Kapag na-install mo na ang lahat ng ito, maaari kang magpatuloy sa paggawa sa aming proyekto.

▍Pag-pack ng isang application sa isang jar file

Mag-navigate, gamit ang isang terminal, sa folder sa-webapp at ipasok ang sumusunod na command:

mvn install

Pagkatapos patakbuhin ang command na ito sa folder sa-webapp isang direktoryo ang gagawin target. Dito matatagpuan ang Java application, na nakabalot sa isang jar file, na kinakatawan ng file sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Pagpapatakbo ng Java application

Pumunta sa folder target at patakbuhin ang application gamit ang sumusunod na command:

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

Ang isang error ay magaganap habang isinasagawa ang utos na ito. Upang simulan ang pag-aayos nito, maaari naming suriin ang mga detalye ng exception sa stack trace data:

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

Para sa amin, ang pinakamahalagang bagay dito ay ang pagbanggit ng imposibilidad ng paglilinaw ng kahulugan sa.logic.api.url. Suriin natin ang code kung saan nangyayari ang error.

▍Pagsusuri ng Java application code

Narito ang snippet ng code kung saan nangyayari ang error.

@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. Sa SentimentController may field saLogicApiUrl. Ang halaga nito ay tinukoy ng ari-arian sa.logic.api.url.
2. Linya saLogicApiUrl magkakaugnay sa halaga /analyse/sentiment. Magkasama silang bumubuo ng address para sa pagtawag sa microservice na nagsasagawa ng pagsusuri sa teksto.

▍Magtakda ng halaga ng ari-arian

Sa Spring, ang karaniwang pinagmumulan ng mga halaga ng ari-arian ay isang file application.properties, na makikita sa sa-webapp/src/main/resources. Ngunit ang paggamit nito ay hindi lamang ang paraan upang magtakda ng mga halaga ng ari-arian. Magagawa rin ito gamit ang sumusunod na command:

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

Ang halaga ng property na ito ay dapat tumuro sa address ng aming Python application.

Sa pamamagitan ng pag-configure nito, sinasabi namin sa Spring web application kung saan ito kailangang pumunta upang magsagawa ng mga kahilingan sa pagsusuri ng teksto.

Upang hindi gawing kumplikado ang aming buhay, magpapasya kami na ang Python application ay magagamit sa localhost:5000 at subukan nating huwag kalimutan ang tungkol dito. Bilang resulta, ang utos na ilunsad ang Spring application ay magiging ganito:

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

Kulang ng Python application ang aming system

Ngayon ang kailangan lang nating gawin ay patakbuhin ang Python application at gagana ang system gaya ng inaasahan.

▍Pag-set up ng Python application

Upang magpatakbo ng isang Python application, dapat ay mayroon kang Python 3 at Pip na naka-install, at ang naaangkop na mga variable ng kapaligiran ay dapat na itakda nang tama.

▍Pag-install ng mga dependency

Pumunta sa iyong folder ng proyekto sa-logic/sa at patakbuhin ang sumusunod na mga utos:

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

▍Ilunsad ang application

Pagkatapos i-install ang mga dependencies, handa na kaming patakbuhin ang application:

python sentiment_analysis.py

Pagkatapos patakbuhin ang utos na ito ay sasabihin sa amin ang sumusunod:

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

Nangangahulugan ito na ang application ay tumatakbo at naghihintay para sa mga kahilingan sa localhost:5000/

▍ Code Research

Tingnan natin ang code ng application ng Python upang maunawaan kung paano ito tumutugon sa mga kahilingan:

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. Pagsisimula ng isang bagay Flask.
2. Pagtukoy ng isang address para sa pagsasagawa ng mga kahilingan sa POST dito.
3. Pagkuha ng Ari-arian sentence mula sa katawan ng kahilingan.
4. Pagsisimula ng Anonymous na Bagay TextBlob at pagkuha ng halaga polarity para sa unang pangungusap na natanggap sa katawan ng kahilingan (sa aming kaso, ito ang tanging pangungusap na ipinadala para sa pagsusuri).
5. Pagbabalik ng tugon na ang katawan ay naglalaman ng teksto ng pangungusap at ang kalkuladong tagapagpahiwatig para dito polarity.
6. Maglunsad ng Flask application, na magiging available sa 0.0.0.0:5000 (maaari mo rin itong i-access gamit ang isang pagbuo ng form localhost:5000).

Ang mga microservice na bumubuo sa application ay tumatakbo na ngayon. Sila ay nakatutok upang makipag-ugnayan sa isa't isa. Ito ang hitsura ng application diagram sa yugtong ito ng trabaho.

Ang lahat ng mga microservice na bumubuo sa application ay dinadala sa ayos ng trabaho

Ngayon, bago ka magpatuloy, buksan ang iyong React application sa isang browser at subukang mag-parse ng ilang pangungusap dito. Kung ang lahat ay tapos na nang tama - pagkatapos ng pagpindot sa pindutan Send makikita mo ang mga resulta ng pagsusuri sa ibaba ng field ng teksto.

Sa susunod na seksyon, pag-uusapan natin kung paano patakbuhin ang aming mga microservice sa mga container ng Docker. Ito ay kinakailangan upang maihanda ang application na tumakbo sa Kubernetes cluster.

Mga lalagyan ng docker

Kubernetes ay isang sistema para sa pag-automate ng pag-deploy, pag-scale at pamamahala ng mga containerized na application. Tinatawag din itong "container orchestrator". Kung gumagana ang Kubernetes sa mga container, bago gamitin ang system na ito kailangan muna nating makuha ang mga container na ito. Ngunit una, pag-usapan natin kung ano ang mga lalagyan. Marahil ang pinakamahusay na sagot sa tanong kung ano ito ay matatagpuan dokumentasyon sa Docker:

Ang isang container na imahe ay isang magaan, self-contained, executable package na naglalaman ng isang application, na kinabibilangan ng lahat ng kailangan para patakbuhin ito: application code, execution environment, system tools at library, mga setting. Maaaring gamitin ang mga naka-container na program sa Linux at Windows environment, at palagi silang gagana nang pareho anuman ang imprastraktura.

Nangangahulugan ito na ang mga lalagyan ay maaaring patakbuhin sa anumang computer, kabilang ang mga server ng produksyon, at ang mga application na nakapaloob sa mga ito ay gagana nang pareho sa anumang kapaligiran.

Upang galugarin ang mga tampok ng mga container at ihambing ang mga ito sa iba pang mga paraan upang magpatakbo ng mga application, tingnan natin ang isang halimbawa ng paghahatid ng isang React application gamit ang isang virtual machine at isang container.

▍Paghahatid ng mga static na file ng isang React application gamit ang isang virtual machine

Sinusubukang ayusin ang serbisyo ng mga static na file gamit ang mga virtual machine, makakatagpo kami ng mga sumusunod na disadvantages:

1. Hindi mahusay na paggamit ng mga mapagkukunan, dahil ang bawat virtual machine ay isang ganap na operating system.
2. Dependency sa platform. Ang gumagana sa isang lokal na computer ay maaaring hindi gumana sa isang production server.
3. Mabagal at resource-intensive scaling ng isang virtual machine-based na solusyon.

Ang Nginx web server ay naghahatid ng mga static na file na tumatakbo sa isang virtual machine

Kung ang mga lalagyan ay ginagamit upang malutas ang isang katulad na problema, kung ihahambing sa mga virtual machine, ang mga sumusunod na lakas ay maaaring mapansin:

1. Mahusay na paggamit ng mga mapagkukunan: nagtatrabaho sa operating system gamit ang Docker.
2. Independiyenteng platform. Ang isang container na maaaring patakbuhin ng isang developer sa kanyang computer ay gagana kahit saan.
3. Magaang deployment sa pamamagitan ng paggamit ng mga layer ng imahe.

Ang Nginx web server ay naghahatid ng mga static na file na tumatakbo sa isang lalagyan

Inihambing lang namin ang mga virtual machine at container sa ilang punto, ngunit kahit na ito ay sapat na upang madama ang lakas ng mga container. Dito Makakahanap ka ng mga detalye tungkol sa mga container ng Docker.

▍Pagbuo ng imahe ng lalagyan para sa isang React na application

Ang pangunahing bloke ng gusali ng isang lalagyan ng Docker ay ang file Dockerfile. Sa simula ng file na ito, ang isang talaan ay ginawa ng batayang imahe ng lalagyan, pagkatapos ay mayroong isang pagkakasunud-sunod ng mga tagubilin na nagpapahiwatig kung paano lumikha ng isang lalagyan na makakatugon sa mga pangangailangan ng isang partikular na aplikasyon.

Bago tayo magsimulang magtrabaho kasama ang file Dockerfile, tandaan natin kung ano ang ginawa namin upang ihanda ang mga file ng React application para sa pag-upload sa Nginx server:

1. Pagbuo ng isang React application package (npm run build).
2. Pagsisimula ng Nginx server.
3. Pagkopya ng mga nilalaman ng direktoryo build mula sa folder ng proyekto sa-frontend sa folder ng server nginx/html.

Sa ibaba makikita mo ang mga pagkakatulad sa pagitan ng paggawa ng container at ng mga hakbang sa itaas na ginawa sa iyong lokal na computer.

▍Paghahanda ng Dockerfile para sa SA-Frontend na application

Ang mga tagubilin na ipapaloob sa Dockerfile para sa aplikasyon SA-Frontend, binubuo ng dalawang koponan lamang. Ang katotohanan ay ang pangkat ng pag-unlad ng Nginx ay naghanda ng isang pangunahing isang imahe para sa Nginx, na gagamitin namin upang lumikha ng aming imahe. Ito ang dalawang hakbang na kailangan nating ilarawan:

1. Ang batayan ng imahe ay dapat na ang Nginx na imahe.
2. Mga Nilalaman ng Folder sa-frontend/build kailangang kopyahin sa folder ng imahe nginx/html.

Kung pupunta ka mula sa paglalarawang ito sa file Dockerfile, pagkatapos ay magiging ganito ang hitsura:

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

Tulad ng nakikita mo, ang lahat dito ay napaka-simple, at ang mga nilalaman ng file ay naging medyo nababasa at naiintindihan. Sinasabi ng file na ito sa system na kunin ang larawan nginx kasama ang lahat na nasa loob nito, at kopyahin ang mga nilalaman ng direktoryo build sa direktoryo nginx/html.

Dito maaari kang magkaroon ng isang katanungan tungkol sa kung paano ko malalaman kung saan eksaktong kailangan mong kopyahin ang mga file mula sa folder build, ibig sabihin, kung saan nagmula ang landas /usr/share/nginx/html. Sa katunayan, wala ring kumplikado dito. Ang katotohanan ay ang nauugnay na impormasyon ay matatagpuan sa paglalarawan imahe

▍Pagbuo ng larawan at pag-upload nito sa repositoryo

Bago tayo makapagtrabaho sa natapos na larawan, kailangan nating itulak ito sa repositoryo ng larawan. Para magawa ito, gagamitin namin ang libreng cloud image hosting platform na Docker Hub. Sa yugtong ito ng trabaho kailangan mong gawin ang mga sumusunod:

1. Upang mai-install Manggagawa sa pantalan.
2. Magrehistro sa website ng Docker Hub.
3. Mag-log in sa iyong account sa pamamagitan ng pagpapatakbo ng sumusunod na command sa terminal:

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

Ngayon ay kailangan mong gamitin ang terminal upang pumunta sa direktoryo sa-frontend at patakbuhin ang sumusunod na utos doon:

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

Dito at higit pa sa mga katulad na utos $DOCKER_USER_ID dapat mapalitan ng iyong Docker Hub username. Halimbawa, ang bahaging ito ng utos ay maaaring magmukhang ganito: rinormaloku/sentiment-analysis-frontend.

Sa kasong ito, ang utos na ito ay maaaring paikliin sa pamamagitan ng pag-alis mula dito -f Dockerfile, dahil ang file na ito ay umiiral na sa folder kung saan namin isinasagawa ang utos na ito.

Upang maipadala ang natapos na imahe sa imbakan, kailangan namin ang sumusunod na utos:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Pagkatapos makumpleto ito, tingnan ang listahan ng iyong mga repository sa Docker Hub upang maunawaan kung matagumpay ang pag-upload ng larawan sa cloud storage.

▍Pagpapatakbo ng lalagyan

Ngayon kahit sino ay maaaring mag-download at magpatakbo ng larawan, na kilala bilang $DOCKER_USER_ID/sentiment-analysis-frontend. Upang magawa ito, kailangan mong patakbuhin ang sumusunod na pagkakasunud-sunod ng mga utos:

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

Ngayon ay tumatakbo na ang lalagyan, maaari tayong magpatuloy sa paggawa sa pamamagitan ng paggawa ng iba pang mga larawang kailangan natin. Ngunit bago tayo magpatuloy, unawain natin ang disenyo 80:80, na lumilitaw sa utos ng paglulunsad ng imahe at maaaring mukhang nakakalito.

• Unang numero 80 — ito ang host port number (iyon ay, ang lokal na computer).
• Pangalawang numero 80 ay ang port ng container kung saan dapat ipasa ang kahilingan.

Isaalang-alang ang sumusunod na ilustrasyon.

Pagpapasa ng Port

Inire-redirect ng system ang mga kahilingan mula sa port <hostPort> sa daungan <containerPort>. Ibig sabihin, access sa port 80 ang computer ay na-redirect sa port 80 lalagyan.

Mula sa daungan 80 binuksan sa lokal na computer, pagkatapos ay maa-access mo ang application mula sa computer na ito sa localhost:80. Kung hindi sinusuportahan ng iyong system ang Docker, ang application ay maaaring patakbuhin sa isang Docker virtual machine, ang address kung saan magmumukhang <docker-machine ip>:80. Upang malaman ang IP address ng Docker virtual machine, maaari mong gamitin ang command docker-machine ip.

Sa puntong ito, pagkatapos matagumpay na ilunsad ang lalagyan ng front-end na application, dapat mong mabuksan ang pahina nito sa browser.

▍Ang .dockerignore file

Pagkolekta ng larawan ng application SA-Frontend, maaari naming mapansin na ang prosesong ito ay lumalabas na napakabagal. Nangyayari ito dahil ang konteksto ng pagbuo ng imahe ay dapat ipadala sa Docker daemon. Ang direktoryo na kumakatawan sa konteksto ng build ay tinukoy bilang huling argumento ng command docker build. Sa aming kaso, mayroong isang tuldok sa dulo ng utos na ito. Ito ay nagiging sanhi ng sumusunod na istraktura upang maisama sa konteksto ng build:

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

Ngunit sa lahat ng mga folder na naroroon, kailangan lang namin ang folder build. Ang pag-load ng anupaman ay isang pag-aaksaya ng oras. Maaari mong pabilisin ang pagbuo sa pamamagitan ng pagsasabi sa Docker kung aling mga direktoryo ang hindi dapat pansinin. Ito ay upang magawa ito na kailangan namin ang file .dockerignore. Ikaw, kung pamilyar ka sa file .gitignore, malamang na pamilyar ang istraktura ng file na ito. Naglilista ito ng mga direktoryo na maaaring balewalain ng sistema ng pagbuo ng imahe. Sa aming kaso, ang mga nilalaman ng file na ito ay ganito ang hitsura:

node_modules
src
public

talaksan .dockerignore dapat nasa parehong folder ng file Dockerfile. Ngayon, ang pagbuo ng imahe ay tatagal ng ilang segundo.

Gawin natin ngayon ang larawan para sa Java application.

▍Pagbuo ng imahe ng lalagyan para sa isang Java application

Alam mo, natutunan mo na ang lahat ng kailangan mong malaman upang lumikha ng mga larawan ng lalagyan. Kaya naman magiging napakaikli ng seksyong ito.

Buksan ang file Dockerfilena nasa folder ng proyekto sa-webapp. Kung babasahin mo ang teksto ng file na ito, makikita mo lamang ang dalawang bagong constructions dito, simula sa mga keyword ENV и EXPOSE:

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

Keyword ENV Binibigyang-daan kang magdeklara ng mga variable ng kapaligiran sa loob ng mga container ng Docker. Sa partikular, sa aming kaso, pinapayagan ka nitong tukuyin ang isang URL upang ma-access ang API ng application na nagsasagawa ng pagsusuri ng teksto.

Keyword EXPOSE ay nagpapahintulot sa iyo na sabihin sa Docker na magbukas ng isang port. Gagamitin namin ang port na ito habang pinapatakbo ang application. Dito mo mapapansin iyon sa Dockerfile para sa aplikasyon SA-Frontend walang ganyang utos. Ito ay para lamang sa mga layunin ng dokumentasyon, sa madaling salita, ang konstruksiyon na ito ay inilaan para sa isang magbabasa Dockerfile.

Ang pagbuo ng imahe at pagtulak nito sa repository ay mukhang eksaktong kapareho ng sa nakaraang halimbawa. Kung hindi ka pa masyadong tiwala sa iyong mga kakayahan, ang kaukulang mga utos ay matatagpuan sa file README.md sa folder sa-webapp.

▍Pagbuo ng imahe ng lalagyan para sa isang Python application

Kung titingnan mo ang mga nilalaman ng file Dockerfile sa folder sa-logic, pagkatapos ay wala kang makikitang bago para sa iyong sarili doon. Ang mga utos para sa pagbuo ng imahe at pagpapadala nito sa repositoryo ay dapat ding pamilyar sa iyo, ngunit, tulad ng aming iba pang mga application, sila ay matatagpuan sa file. README.md sa folder sa-logic.

▍Sinusubukan ang mga containerized na application

Maaari ka bang magtiwala sa isang bagay na hindi mo pa nasusubok? hindi ko rin kaya. Subukan natin ang ating mga lalagyan.

1. Ilunsad natin ang lalagyan ng application sa-logic at i-configure ito upang makinig sa port 5050:

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

2. Ilunsad natin ang lalagyan ng application sa-webapp at i-configure ito upang makinig sa port 8080. Bilang karagdagan, kailangan nating i-configure ang port kung saan makikinig ang Python application para sa mga kahilingan mula sa Java application sa pamamagitan ng muling pagtatalaga ng environment variable 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

Upang matutunan kung paano malaman ang IP address ng isang Docker container o virtual machine, sumangguni sa file README.

Ilunsad natin ang lalagyan ng application sa-frontend:

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

Ngayon ang lahat ay handa na upang pumunta sa address sa browser localhost:80 at subukan ang application.

Pakitandaan na kung binago mo ang port para sa sa-webapp, o kung nagpapatakbo ka ng Docker virtual machine, kakailanganin mong i-edit ang file App.js mula sa isang folder sa-frontendsa pamamagitan ng pagpapalit ng IP address o port number sa pamamaraan analyzeSentence(), pinapalitan ang kasalukuyang impormasyon sa halip na hindi napapanahong data. Pagkatapos nito, kailangan mong muling buuin ang imahe at gamitin ito.

Ito ang hitsura ng aming application diagram ngayon.

Ang mga microservice ay tumatakbo sa mga lalagyan

Buod: bakit kailangan natin ng Kubernetes cluster?

Sinuri namin ang mga file Dockerfile, napag-usapan kung paano bumuo ng mga imahe at itulak ang mga ito sa isang imbakan ng Docker. Bilang karagdagan, natutunan namin kung paano pabilisin ang pagpupulong ng imahe gamit ang file .dockerignore. Bilang resulta, tumatakbo na ngayon ang aming mga microservice sa mga container ng Docker. Dito maaari kang magkaroon ng ganap na makatwirang tanong tungkol sa kung bakit kailangan namin ng Kubernetes. Ang ikalawang bahagi ng materyal na ito ay ilalaan sa pagsagot sa tanong na ito. Samantala, isaalang-alang ang sumusunod na tanong:
Ipagpalagay natin na ang aming web application para sa pagsusuri ng teksto ay naging popular sa buong mundo. Milyun-milyong kahilingan ang dumarating sa kanya bawat minuto. Nangangahulugan ito na ang mga microservice sa-webapp и sa-logic ay nasa ilalim ng napakalaking pagkarga. Paano sukatin ang mga lalagyan na nagpapatakbo ng mga microservice?

Pinagmulan: www.habr.com