🥇Kubernetes-ის სახელმძღვანელო ნაწილი 1: აპლიკაციები, მიკროსერვისები და კონტეინერები

ჩვენი თხოვნით, ჰაბრმა შექმნა ჰაბი კუბერნეტები და ჩვენ მოხარულნი ვართ მასში განვათავსოთ პირველი პუბლიკაცია. გამოიწერეთ!

Kubernetes მარტივია. რატომ იხდიან ბანკები დიდ ფულს ამ სფეროში მუშაობისთვის, მაშინ როცა ნებისმიერს შეუძლია ამ ტექნოლოგიას რამდენიმე საათში დაეუფლოს?

თუ ეჭვი გეპარებათ, რომ Kubernetes შეიძლება ასე სწრაფად ისწავლოთ, გირჩევთ, თავად სცადოთ ამის გაკეთება. კერძოდ, ამ მასალის ათვისების შემდეგ, თქვენ შეძლებთ კუბერნეტის კლასტერში მიკროსერვისებზე დაფუძნებული აპლიკაციის გაშვებას. ამის გარანტია შემიძლია, რადგან სწორედ იმ მეთოდოლოგიით, რომელსაც აქ ვიყენებ, ვასწავლი ჩვენს კლიენტებს Kubernetes-თან მუშაობას. რით განსხვავდება ეს სახელმძღვანელო სხვებისგან? სინამდვილეში, ბევრი რამ. ასე რომ, ამ მასალების უმეტესობა იწყება მარტივი საგნების ახსნით - Kubernetes-ის ცნებები და kubectl ბრძანების მახასიათებლები. ამ სტატიების ავტორები ვარაუდობენ, რომ მათი მკითხველი იცნობს აპლიკაციების შემუშავებას, მიკროსერვისებს და Docker კონტეინერებს. ჩვენ სხვა გზით წავალთ. პირველ რიგში, მოდით ვისაუბროთ იმაზე, თუ როგორ უნდა გაუშვათ პროგრამა კომპიუტერზე მიკროსერვისებზე დაფუძნებული. შემდეგ ჩვენ გადავხედავთ კონტეინერების სურათებს თითოეული მიკროსერვისისთვის. ამის შემდეგ კი გავიცნობთ Kubernetes-ს და გავაანალიზებთ მიკროსერვისებზე დაფუძნებული აპლიკაციის განთავსებას Kubernetes-ის მიერ მართულ კლასტერში.

ეს მიდგომა, თანდათანობითი მიდგომით Kubernetes-ის მიმართ, მისცემს ღრმა გაგებას იმის შესახებ, თუ რა ხდება, რაც საშუალო ადამიანს სჭირდება, რათა გაიგოს, რამდენად მარტივად არის ყველაფერი მოწყობილი Kubernetes-ში. Kubernetes, რა თქმა უნდა, მარტივი ტექნოლოგიაა, იმ პირობით, რომ ვისაც სურს მისი დაუფლება, იცის სად და როგორ გამოიყენება.

ახლა, ყოველგვარი აჟიოტაჟის გარეშე, დავიწყოთ მუშაობა და ვისაუბროთ აპლიკაციაზე, რომლითაც ვიმუშავებთ.

ექსპერიმენტული აპლიკაცია

ჩვენი აპლიკაცია შეასრულებს მხოლოდ ერთ ფუნქციას. იგი იღებს, როგორც შეყვანის, ერთი წინადადება, რის შემდეგაც ტექსტის ანალიზის ხელსაწყოების გამოყენებით ახორციელებს ამ წინადადების სენტიმენტალურ ანალიზს, იღებს შეფასებას წინადადების ავტორის ემოციური დამოკიდებულების შესახებ გარკვეული ობიექტის მიმართ.

ასე გამოიყურება ამ აპლიკაციის მთავარი ფანჯარა.

განწყობის ანალიზის ვებ აპლიკაცია

ტექნიკური თვალსაზრისით, აპლიკაცია შედგება სამი მიკროსერვისისგან, რომელთაგან თითოეული წყვეტს ამოცანების გარკვეულ კომპლექტს:

SA-Frontend არის Nginx ვებ სერვერი, რომელიც ემსახურება React სტატიკურ ფაილებს.
SA-WebApp არის Java-ში დაწერილი ვებ აპლიკაცია, რომელიც ამუშავებს მოთხოვნებს წინა ნაწილიდან.
SA-Logic არის პითონის აპლიკაცია, რომელიც ახორციელებს ტექსტის განწყობის ანალიზს.

მნიშვნელოვანია აღინიშნოს, რომ მიკროსერვისები იზოლირებულად არ არსებობს. ისინი ახორციელებენ „მოვალეობების გამიჯვნის“ იდეას, მაგრამ, ამავე დროს, სჭირდებათ ერთმანეთთან ურთიერთობა.

მონაცემები მიედინება აპლიკაციაში

ზემოთ მოცემულ დიაგრამაში შეგიძლიათ იხილოთ სისტემის დანომრილი ეტაპები, რომლებიც ასახავს აპლიკაციაში მონაცემთა ნაკადებს. მოდით დავშალოთ ისინი:

ბრაუზერი ითხოვს ფაილს სერვერიდან index.html (რაც თავის მხრივ იტვირთება React აპის პაკეტს).
მომხმარებელი ურთიერთქმედებს აპლიკაციასთან, ეს იწვევს ზარს გაზაფხულზე დაფუძნებულ ვებ აპლიკაციაში.
ვებ-აპლიკაცია ტექსტის გარჩევის მოთხოვნას გადასცემს Python აპლიკაციას.
პითონის აპლიკაცია აანალიზებს ტექსტის სენტიმენტს და აბრუნებს შედეგს მოთხოვნის პასუხად.
Spring აპლიკაცია აგზავნის პასუხს React აპლიკაციაზე (რომელიც, თავის მხრივ, მომხმარებელს უჩვენებს გაანალიზებული ტექსტის შედეგს).

ყველა ამ აპლიკაციის კოდი შეგიძლიათ იხილოთ აქ. გირჩევთ, ეს საცავი ახლავე დააკოპიროთ საკუთარ თავს, რადგან წინ ბევრი საინტერესო ექსპერიმენტი გველის.

მიკროსერვისებზე დაფუძნებული აპლიკაციის გაშვება ადგილობრივ მანქანაზე

იმისთვის, რომ აპლიკაციამ იმუშაოს, სამივე მიკროსერვისი უნდა დავიწყოთ. დავიწყოთ მათგან ყველაზე ლამაზით - წინა აპლიკაციით.

▍ React-ის დაყენება ადგილობრივი განვითარებისთვის

React აპლიკაციის გასაშვებად, თქვენ უნდა დააინსტალიროთ Node.js Framework და NPM თქვენს კომპიუტერში. ამ ყველაფრის დაინსტალირების შემდეგ გადადით ტერმინალის გამოყენებით პროექტის საქაღალდეში sa-frontend და გაუშვით შემდეგი ბრძანება:

npm install

საქაღალდეში ამ ბრძანების შესრულებით node_modules ჩაიტვირთება React აპლიკაციის დამოკიდებულებები, რომელთა ჩანაწერები არის ფაილში package.json. იმავე საქაღალდეში დამოკიდებულებების ჩამოტვირთვის შემდეგ, გაუშვით შემდეგი ბრძანება:

npm start

Სულ ეს არის. React აპი ახლა გაშვებულია და მისი წვდომა შესაძლებელია ბრაუზერის მისამართის ნავიგაციით localhost:3000. თქვენ შეგიძლიათ შეცვალოთ რაღაც მის კოდში. თქვენ დაუყოვნებლივ დაინახავთ ამ ცვლილებების ეფექტს ბრაუზერში. ეს შესაძლებელია მოდულების ე.წ „ცხელი“ გამოცვლის წყალობით. ამის წყალობით, ფრონტ-ენდის განვითარება იქცევა მარტივ და სასიამოვნო გამოცდილებად.

▍ React აპლიკაციის მომზადება წარმოებისთვის

React აპლიკაციის რეალურად გამოყენების მიზნებისთვის, ჩვენ უნდა გადავიყვანოთ იგი სტატიკური ფაილების ნაკრებად და მივაწოდოთ ისინი კლიენტებს ვებ სერვერის გამოყენებით.

React აპლიკაციის ასაშენებლად, კვლავ ტერმინალის გამოყენებით, გადადით საქაღალდეში sa-frontend და გაუშვით შემდეგი ბრძანება:

npm run build

ეს შექმნის დირექტორიას პროექტის საქაღალდეში build. ის შეიცავს ყველა სტატიკურ ფაილს, რომელიც საჭიროა React აპლიკაციის მუშაობისთვის.

▍ სტატიკური ფაილების მომსახურება Nginx-ით

ჯერ უნდა დააინსტალიროთ და გაუშვათ Nginx ვებ სერვერი. აქ შეგიძლიათ ჩამოტვირთოთ და იპოვოთ ინსტრუქციები მისი ინსტალაციისა და გაშვებისთვის. შემდეგ თქვენ უნდა დააკოპიროთ საქაღალდის შინაარსი sa-frontend/build საქაღალდეში [your_nginx_installation_dir]/html.

ამ მიდგომით, ფაილი წარმოიქმნება React აპლიკაციის ასამბლეის დროს index.html ხელმისაწვდომი იქნება [your_nginx_installation_dir]/html/index.html. ეს არის ფაილი, რომელსაც ნაგულისხმევად, Nginx სერვერი უშვებს მასზე წვდომისას. სერვერი კონფიგურირებულია პორტზე მოსასმენად 80, მაგრამ თქვენ შეგიძლიათ დააკონფიგურიროთ ის ისე, როგორც გსურთ ფაილის რედაქტირებით [your_nginx_installation_dir]/conf/nginx.conf.

ახლა გახსენით თქვენი ბრაუზერი და გადადით localhost:80. თქვენ ნახავთ React აპის გვერდს.

React აპლიკაცია, რომელსაც ემსახურება Nginx სერვერი

თუ ახლა შეიტანეთ რაიმე მინდორში Type your sentence და დააჭირეთ ღილაკს Send - არაფერი მოხდება. მაგრამ, თუ კონსოლს დააკვირდებით, იქ ნახავთ შეცდომის შეტყობინებებს. იმისათვის, რომ გავიგოთ ზუსტად სად ხდება ეს შეცდომები, გავაანალიზოთ განაცხადის კოდი.

▍Front-end აპლიკაციის კოდის ანალიზი

ფაილის კოდს ვუყურებ App.js, ჩვენ ვხედავთ, რომ ღილაკზე დაჭერით Send მეთოდს უწოდებს analyzeSentence(). ამ მეთოდის კოდი ნაჩვენებია ქვემოთ. ამავდროულად, ყურადღება მიაქციეთ იმ ფაქტს, რომ თითოეული ხაზისთვის, რომელზეც არის ფორმის კომენტარი # Номерკოდის ქვემოთ მოცემულია განმარტება. ანალოგიურად, ჩვენ გავაანალიზებთ სხვა კოდის ფრაგმენტებს.

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. URL, რომელზეც შესრულებულია POST მოთხოვნა. ეს მისამართი ითვლება აპლიკაციად, რომელიც ელოდება ასეთ მოთხოვნებს.

2.განაცხადის გაგზავნილი მოთხოვნის ორგანო. აქ არის მოთხოვნის ორგანოს მაგალითი:

{
    sentence: "I like yogobella!"
}

3.როდესაც მოთხოვნაზე პასუხი მიიღება, კომპონენტის მდგომარეობა განახლდება. ეს იწვევს კომპონენტის ხელახლა გადაცემას. თუ ჩვენ მივიღებთ მონაცემებს (ანუ JSON ობიექტს, რომელიც შეიცავს შეყვანილ მონაცემებს და გამოთვლილ ტექსტურ ქულას), გამოვიტანთ კომპონენტს Polarityსანამ პირობები დაკმაყოფილებულია. აი, როგორ აღვწერთ კომპონენტს:

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

როგორც ჩანს, კოდი საკმაოდ კარგად მუშაობს. მაინც რა არის აქ ცუდი? თუ ჩათვლით, რომ იმ მისამართზე, რომელზედაც აპლიკაცია ცდილობს POST მოთხოვნის გაგზავნას, ჯერ არაფერია, რაც ამ მოთხოვნის მიღებას და დამუშავებას შეძლებს, მაშინ აბსოლუტურად მართალი იქნებით. კერძოდ, მისამართზე შემოსული მოთხოვნების დამუშავება http://localhost:8080/sentiment, ჩვენ გვჭირდება ვებ აპლიკაციის გაშვება Spring-ზე დაფუძნებული.

ჩვენ გვჭირდება საგაზაფხულო აპლიკაცია, რომელსაც შეუძლია მიიღოს POST მოთხოვნა

▍ გაზაფხულის საფუძველზე ვებ აპლიკაციის დაყენება

Spring აპლიკაციის განსათავსებლად გჭირდებათ JDK8 და Maven და სათანადოდ კონფიგურირებული გარემოს ცვლადები. ამ ყველაფრის დაინსტალირების შემდეგ შეგიძლიათ განაგრძოთ მუშაობა ჩვენს პროექტზე.

▍აპლიკაციის შეფუთვა jar ფაილში

ტერმინალის გამოყენებით გადადით საქაღალდეში sa-webapp და შეიყვანეთ შემდეგი ბრძანება:

mvn install

საქაღალდეში ამ ბრძანების შესრულების შემდეგ sa-webapp დირექტორია შეიქმნება target. სწორედ აქ განთავსდება Java აპლიკაცია, შეფუთული jar ფაილში, წარმოდგენილი ფაილით sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ Java აპლიკაციის გაშვება

გადადით საქაღალდეში target და გაუშვით აპლიკაცია შემდეგი ბრძანებით:

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

ამ ბრძანების შესრულებისას მოხდება შეცდომა. მისი გამოსწორების დასაწყებად, ჩვენ შეგვიძლია გავაანალიზოთ გამონაკლისის დეტალები სტეკის კვალის მონაცემებში:

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

ჩვენთვის აქ მთავარია მნიშვნელობის გარკვევის შეუძლებლობის ხსენება sa.logic.api.url. მოდით გავაანალიზოთ კოდი, სადაც ხდება შეცდომა.

▍ Java აპლიკაციის კოდის ანალიზი

აქ არის კოდის ნაწყვეტი, სადაც ხდება შეცდომა.

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

სentimentController არის ველი saLogicApiUrl. მის ღირებულებას ადგენს ქონება sa.logic.api.url.
ხაზი saLogicApiUrl აერთიანებს ღირებულებას /analyse/sentiment. ისინი ერთად ქმნიან მისამართს მიკროსერვისთან დასარეკად, რომელიც ახორციელებს ტექსტის ანალიზს.

▍ ქონების ღირებულების დაყენება

გაზაფხულზე, ქონების მნიშვნელობების ნაგულისხმევი წყარო არის ფაილი application.properties, რომელიც შეგიძლიათ იხილოთ sa-webapp/src/main/resources. მაგრამ მისი გამოყენება არ არის ქონების მნიშვნელობების დაყენების ერთადერთი გზა. თქვენ ასევე შეგიძლიათ ამის გაკეთება შემდეგი ბრძანებით:

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

ამ ქონების ღირებულება უნდა მიუთითებდეს ჩვენი Python აპლიკაციის მისამართზე.

მისი კონფიგურაციით, ჩვენ ვეუბნებით Spring ვებ აპლიკაციას, სად უნდა წავიდეს ტექსტის გარჩევის მოთხოვნების შესასრულებლად.

იმისათვის, რომ არ გავართულოთ ჩვენი ცხოვრება, ჩვენ გადავწყვეტთ, რომ Python აპლიკაცია ხელმისაწვდომი იქნება მისამართზე localhost:5000 და შეეცადეთ არ დაივიწყოთ ეს. შედეგად, Spring აპლიკაციის დაწყების ბრძანება ასე გამოიყურება:

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

ჩვენს სისტემას აკლია Python აპლიკაცია

ახლა ჩვენ უბრალოდ უნდა გავუშვათ Python აპლიკაცია და სისტემა იმუშავებს ისე, როგორც მოსალოდნელია.

▍პითონის აპლიკაციის დაყენება

Python-ის აპლიკაციის გასაშვებად, თქვენ უნდა გქონდეთ დაინსტალირებული Python 3 და Pip და უნდა გქონდეთ სწორად დაყენებული გარემოს შესაბამისი ცვლადები.

▍დამოკიდებულებების დაყენება

გადადით პროექტის საქაღალდეში sa-logic/sa და გაუშვით შემდეგი ბრძანებები:

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

▍აპლიკაციის გაშვება

დამოკიდებულებების დაყენებით, ჩვენ მზად ვართ გაუშვათ აპლიკაცია:

python sentiment_analysis.py

ამ ბრძანების შესრულების შემდეგ გვეუბნებიან შემდეგი:

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

ეს ნიშნავს, რომ აპლიკაცია მუშაობს და ელოდება მოთხოვნებს localhost:5000/

▍კოდების კვლევა

მოდით გადავხედოთ Python-ის აპლიკაციის კოდს, რათა გავიგოთ, როგორ პასუხობს ის მოთხოვნებს:

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

ობიექტის ინიციალიზაცია Flask.
მისამართის მითითება POST-ის მოთხოვნის მისაღებად.
ქონების მოპოვება sentence მოთხოვნის ორგანოდან.
ანონიმური ობიექტის ინიციალიზაცია TextBlob და ღირებულების მიღება polarity მოთხოვნის სხეულში მიღებული პირველი წინადადებისთვის (ჩვენს შემთხვევაში ეს არის ანალიზისთვის წარმოდგენილი ერთადერთი წინადადება).
პასუხის დაბრუნება, რომლის ტექსტი შეიცავს შეთავაზების ტექსტს და მისთვის გამოთვლილ ინდიკატორს polarity.
Flask აპლიკაციის გაშვება, რომელიც ხელმისაწვდომი იქნება აქ 0.0.0.0:5000 (ასევე შეგიძლიათ მასზე წვდომა ფორმის კონსტრუქციის გამოყენებით localhost:5000).

ახლა მუშაობს მიკროსერვისები, რომლებიც ქმნიან აპლიკაციას. ისინი მზად არიან ერთმანეთთან ურთიერთობისთვის. აი, როგორ გამოიყურება აპლიკაციის დიაგრამა მუშაობის ამ ეტაპზე.

ყველა მიკროსერვისი, რომელიც აპლიკაციის შემადგენლობაში შედის, ჯანსაღ მდგომარეობაშია

ახლა, სანამ გავაგრძელებთ, გახსენით React აპი ბრაუზერში და შეეცადეთ გაანალიზოთ რამდენიმე წინადადება. თუ ყველაფერი გაკეთდა სწორად - ღილაკის დაჭერის შემდეგ Send თქვენ ნახავთ ანალიზის შედეგებს ტექსტური ველის ქვემოთ.

შემდეგ განყოფილებაში ვისაუბრებთ იმაზე, თუ როგორ გავატაროთ ჩვენი მიკროსერვისები Docker კონტეინერებში. ეს აუცილებელია იმისათვის, რომ მომზადდეს აპლიკაცია Kubernetes კლასტერში გასაშვებად.

დოკერის კონტეინერები

კუბერნეტები არის კონტეინერირებული აპლიკაციების განლაგების, სკალირებისა და მართვის ავტომატიზაციის სისტემა. მას ასევე უწოდებენ "კონტეინერის ორკესტრატორს". თუ Kubernetes მუშაობს კონტეინერებთან, მაშინ ამ სისტემის გამოყენებამდე ჯერ ეს კონტეინერები უნდა შევიძინოთ. მაგრამ ჯერ მოდით ვისაუბროთ იმაზე, თუ რა არის კონტეინერები. ალბათ საუკეთესო პასუხი კითხვაზე, თუ რა არის ეს, შეიძლება მოიძებნოს დოკუმენტაცია დოკერს:

კონტეინერის სურათი არის მსუბუქი, დამოუკიდებელი, შესრულებადი პაკეტი, რომელიც შეიცავს აპლიკაციას, რომელიც მოიცავს ყველაფერს, რაც საჭიროა მისი გასაშვებად: აპლიკაციის კოდი, გაშვების გარემო, სისტემის ხელსაწყოები და ბიბლიოთეკები, პარამეტრები. კონტეინერირებული პროგრამების გამოყენება შესაძლებელია როგორც Linux, ასევე Windows გარემოში და ყოველთვის ერთნაირად იმუშავებს ინფრასტრუქტურის მიუხედავად.

ეს ნიშნავს, რომ კონტეინერების გაშვება შესაძლებელია ნებისმიერ კომპიუტერზე, მათ შორის საწარმოო სერვერებზე და ნებისმიერ გარემოში, მათში ჩასმული აპლიკაციები იმუშავებს იგივე გზით.

კონტეინერების მახასიათებლების შესასწავლად და აპლიკაციების გაშვების სხვა გზებთან შესადარებლად, მოდით შევხედოთ React აპლიკაციის სერვისის მაგალითს ვირტუალური მანქანისა და კონტეინერის გამოყენებით.

▍ React აპლიკაციის სტატიკური ფაილების სერვისი ვირტუალური მანქანის გამოყენებით

ვირტუალური მანქანების გამოყენებით სტატიკური ფაილების მოვლა-პატრონობის ორგანიზების მცდელობისას შეგვხვდება შემდეგი უარყოფითი მხარეები:

რესურსების არაეფექტური გამოყენება, რადგან თითოეული ვირტუალური მანქანა არის სრული ოპერაციული სისტემა.
პლატფორმის დამოკიდებულება. ის, რაც მუშაობს ზოგიერთ ადგილობრივ კომპიუტერზე, შეიძლება არ იმუშაოს წარმოების სერვერზე.
ვირტუალური მანქანის გადაწყვეტის ნელი და რესურსებით ინტენსიური მასშტაბირება.

Nginx ვებ სერვერი ემსახურება სტატიკურ ფაილებს, რომლებიც მუშაობენ ვირტუალურ მანქანაში

თუ კონტეინერები გამოიყენება მსგავსი პრობლემის გადასაჭრელად, მაშინ ვირტუალურ მანქანებთან შედარებით, შეიძლება აღინიშნოს შემდეგი ძლიერი მხარეები:

რესურსების ეფექტური გამოყენება: ოპერაციულ სისტემასთან მუშაობა Docker-ის გამოყენებით.
პლატფორმის დამოუკიდებლობა. კონტეინერი, რომელიც დეველოპერს შეუძლია გაუშვას საკუთარ კომპიუტერზე, იმუშავებს ყველგან.
მსუბუქი განლაგება გამოსახულების ფენების გამოყენებით.

Nginx ვებ სერვერი, რომელიც ემსახურება კონტეინერში გაშვებულ სტატიკურ ფაილებს

ჩვენ მხოლოდ რამდენიმე პუნქტში შევადარეთ ვირტუალური მანქანები და კონტეინერები, მაგრამ ესეც საკმარისია კონტეინერების სიძლიერის შესასწავლად. აქ თქვენ შეგიძლიათ იპოვოთ დეტალები Docker კონტეინერების შესახებ.

▍ კონტეინერის სურათის შექმნა React აპისთვის

Docker კონტეინერის ძირითადი სამშენებლო ბლოკი არის ფაილი Dockerfile. ამ ფაილის დასაწყისში ჩაიწერება კონტეინერის საბაზისო სურათი, შემდეგ შედის ინსტრუქციების თანმიმდევრობა, სადაც მითითებულია, თუ როგორ უნდა შექმნათ კონტეინერი, რომელიც დააკმაყოფილებს აპლიკაციის საჭიროებებს.

სანამ ფაილთან მუშაობას დავიწყებთ Dockerfileდაიმახსოვრე რა გავაკეთეთ იმისათვის, რომ React აპლიკაციის ფაილები მოვამზადოთ Nginx სერვერზე ასატვირთად:

React აპლიკაციის პაკეტის შექმნა (npm run build).
Nginx სერვერის გაშვება.
დირექტორიაში შიგთავსის კოპირება build პროექტის საქაღალდიდან sa-frontend სერვერის საქაღალდეში nginx/html.

ქვემოთ შეგიძლიათ იხილოთ პარალელები კონტეინერის შექმნასა და ადგილობრივ კომპიუტერზე შესრულებულ ზემოხსენებულ მოქმედებებს შორის.

▍Dockerfile-ის მომზადება SA-Frontend აპლიკაციისთვის

ინსტრუქციები ჩართული Dockerfile განაცხადისთვის SA-Frontend, შედგება მხოლოდ ორი გუნდისგან. ფაქტია, რომ Nginx-ის განვითარების გუნდმა მოამზადა ძირითადი გამოსახულება Nginx-ისთვის, რომელსაც გამოვიყენებთ ჩვენი იმიჯის ასაგებად. აქ არის ორი ნაბიჯი, რომელიც უნდა აღვწეროთ:

თქვენ უნდა გააკეთოთ Nginx გამოსახულება სურათის საფუძველი.
საქაღალდის შინაარსი sa-frontend/build უნდა დააკოპიროთ სურათის საქაღალდეში nginx/html.

თუ ამ აღწერიდან ფაილზე გადავალთ Dockerfile, მაშინ ასე გამოიყურება:

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

როგორც ხედავთ, აქ ყველაფერი ძალიან მარტივია, ხოლო ფაილის შინაარსი საკმაოდ იკითხება და გასაგებიც კი აღმოჩნდება. ეს ფაილი ეუბნება სისტემას სურათის გადაღებას nginx ყველაფერთან ერთად, რაც უკვე აქვს და დააკოპირეთ დირექტორიის შინაარსი build დირექტორიაში nginx/html.

აქ შეიძლება გქონდეთ შეკითხვა იმის შესახებ, თუ როგორ ვიცი ზუსტად სად დავაკოპიროთ ფაილები საქაღალდიდან build, ანუ საიდან გაჩნდა გზა /usr/share/nginx/html. სინამდვილეში, აქაც არაფერია რთული. ფაქტია, რომ შესაბამისი ინფორმაცია შეგიძლიათ იხილოთ აქ აღწერა გამოსახულება.

▍ სურათის აწყობა და საცავში ატვირთვა

სანამ შევძლებთ დასრულებულ სურათზე მუშაობას, ის უნდა გამოვიტანოთ სურათების საცავში. ამისათვის ჩვენ გამოვიყენებთ უფასო ღრუბელზე დაფუძნებულ გამოსახულების ჰოსტინგის პლატფორმას Docker Hub. მუშაობის ამ ეტაპზე, თქვენ უნდა გააკეთოთ შემდეგი:

ინსტალაცია docker.
დარეგისტრირდით Docker Hub-ის საიტზე.
შედით თქვენს ანგარიშში ტერმინალში შემდეგი ბრძანების გაშვებით:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

ახლა თქვენ გჭირდებათ, ტერმინალის გამოყენებით, გადადით დირექტორიაში sa-frontend და იქ გაუშვით შემდეგი ბრძანება:

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

აქ და ქვემოთ მსგავსი ბრძანებები $DOCKER_USER_ID უნდა შეიცვალოს თქვენი მომხმარებლის სახელით Docker Hub-ზე. მაგალითად, ბრძანების ეს ნაწილი შეიძლება ასე გამოიყურებოდეს: rinormaloku/sentiment-analysis-frontend.

ამ შემთხვევაში, ეს ბრძანება შეიძლება შემცირდეს მისგან ამოღებით -f Dockerfile, ვინაიდან საქაღალდეში, რომელშიც ჩვენ ვასრულებთ ამ ბრძანებას, უკვე აქვს ეს ფაილი.

მზა სურათის საცავში გასაგზავნად, ჩვენ გვჭირდება შემდეგი ბრძანება:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

მისი დასრულების შემდეგ, შეამოწმეთ თქვენი საცავების სია Docker Hub-ზე, რათა ნახოთ სურათი წარმატებით იქნა გადატანილი ღრუბლოვან საცავში.

▍კონტეინერის გაშვება

ახლა ყველას შეუძლია ჩამოტვირთოთ და გაუშვას სურათი, რომელიც ცნობილია როგორც $DOCKER_USER_ID/sentiment-analysis-frontend. ამისათვის თქვენ უნდა შეასრულოთ ბრძანებების შემდეგი თანმიმდევრობა:

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

ახლა კონტეინერი მუშაობს და ჩვენ შეგვიძლია გავაგრძელოთ მუშაობა ჩვენთვის საჭირო სხვა სურათების შექმნით. მაგრამ სანამ გავაგრძელებთ, მოდით გავიგოთ დიზაინი 80:80, რომელიც გვხვდება გამოსახულების გაშვების ბრძანებაში და შეიძლება დამაბნეველი ჩანდეს.

პირველი ნომერი 80 არის ჰოსტის პორტის ნომერი (ანუ ლოკალური კომპიუტერი).
მეორე ნომერი 80 არის კონტეინერის პორტი, რომელზეც უნდა გადამისამართდეს მოთხოვნა.

განვიხილოთ შემდეგი ილუსტრაცია.

Პორტის გადამისამართება

სისტემა აგზავნის მოთხოვნებს პორტიდან <hostPort> პორტამდე <containerPort>. ანუ პორტში შესვლა 80 კომპიუტერი გადამისამართებულია პორტში 80 კონტეინერი.

პორტიდან მოყოლებული 80 გახსნილია ადგილობრივ კომპიუტერზე, შეგიძლიათ აპლიკაციაზე წვდომა ამ კომპიუტერიდან localhost:80. თუ თქვენს სისტემას არ აქვს Docker-ის მხარდაჭერა, შეგიძლიათ აპლიკაცია გაუშვათ Docker-ის ვირტუალურ მანქანაზე, რომლის მისამართიც ასე გამოიყურება <docker-machine ip>:80. Docker ვირტუალური მანქანის IP მისამართის გასარკვევად, შეგიძლიათ გამოიყენოთ ბრძანება docker-machine ip.

ამ ეტაპზე, როგორც კი წინა აპლიკაციის კონტეინერი წარმატებით ამოქმედდება, თქვენ უნდა შეგეძლოთ მისი გვერდის გახსნა ბრაუზერში.

▍.dockerignore ფაილი

აპლიკაციის სურათის აგება SA-Frontendჩვენ შეგვიძლია შევამჩნიოთ, რომ ეს პროცესი ძალიან ნელია. ეს იმიტომ ხდება, რომ გამოსახულების აგების კონტექსტი უნდა გაიგზავნოს Docker Daemon-ში. დირექტორია, რომელიც წარმოადგენს build კონტექსტს, მოცემულია ბრძანების ბოლო არგუმენტად docker build. ჩვენს შემთხვევაში, ამ ბრძანების ბოლოს არის წერტილი. ეს იწვევს შემდეგ სტრუქტურას, რომელიც შედის შეკრების კონტექსტში:

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

მაგრამ აქ არსებული ყველა საქაღალდედან მხოლოდ საქაღალდე გვჭირდება build. სხვა რამის ჩამოტვირთვა დროის კარგვაა. თქვენ შეგიძლიათ დააჩქაროთ მშენებლობა Docker-ის მითითებით, რომელი დირექტორიების იგნორირება უნდა მოხდეს. ამისათვის ჩვენ გვჭირდება ფაილი .dockerignore. თქვენ, თუ იცნობთ ფაილს .gitignore, ამ ფაილის სტრუქტურა ალბათ ნაცნობი იქნება. მასში ჩამოთვლილია დირექტორიები, რომელთა იგნორირებაც გამოსახულების აგების სისტემას შეუძლია. ჩვენს შემთხვევაში, ამ ფაილის შინაარსი ასე გამოიყურება:

node_modules
src
public

ფაილი .dockerignore უნდა იყოს იმავე საქაღალდეში, როგორც ფაილი Dockerfile. ახლა სურათის აწყობას რამდენიმე წამი დასჭირდება.

ახლა მოდით გავუმკლავდეთ სურათს Java პროგრამისთვის.

▍ კონტეინერის სურათის შექმნა Java აპლიკაციისთვის

თქვენ იცით რა და უკვე ისწავლეთ ყველაფერი, რაც გჭირდებათ კონტეინერის სურათების შესაქმნელად. ამიტომ ეს განყოფილება ძალიან მოკლე იქნება.

გახსენით ფაილი Dockerfile, რომელიც მდებარეობს პროექტის საქაღალდეში sa-webapp. თუ წაიკითხავთ ამ ფაილის ტექსტს, მაშინ მასში შეხვდებით მხოლოდ ორ ახალ კონსტრუქციას, რომლებიც იწყება საკვანძო სიტყვებით ENV и EXPOSE:

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

საკვანძო სიტყვა ENV საშუალებას გაძლევთ გამოაცხადოთ გარემოს ცვლადები Docker კონტეინერებში. კერძოდ, ჩვენს შემთხვევაში, ის საშუალებას გაძლევთ დააყენოთ URL აპლიკაციის API-ზე წვდომისთვის, რომელიც ახორციელებს ტექსტის ანალიზს.

საკვანძო სიტყვა EXPOSE საშუალებას გაძლევთ უთხრათ Docker-ს პორტის გახსნა. ჩვენ ვაპირებთ ამ პორტის გამოყენებას აპლიკაციასთან მუშაობისას. აქ შეგიძლიათ ნახოთ ეს Dockerfile განაცხადისთვის SA-Frontend ასეთი ბრძანება არ არსებობს. ეს არის მხოლოდ დოკუმენტაციის მიზნებისთვის, სხვა სიტყვებით რომ ვთქვათ, ეს კონსტრუქცია არის მკითხველისთვის Dockerfile.

სურათის აგება და საცავში გადატანა ზუსტად ისე გამოიყურება, როგორც წინა მაგალითი. თუ ჯერ კიდევ არ ხართ დარწმუნებული თქვენს შესაძლებლობებში, შესაბამისი ბრძანებები შეგიძლიათ იხილოთ ფაილში README.md საქაღალდეში sa-webapp.

▍კონტეინერის სურათის შექმნა პითონის აპლიკაციისთვის

თუ გადავხედავთ ფაილის შინაარსს Dockerfile საქაღალდეში sa-logicიქ ვერაფერ ახალს ვერ იპოვით. გამოსახულების აგების და საცავში გადატანის ბრძანებები ასევე უნდა იყოს თქვენთვის ნაცნობი, მაგრამ, როგორც ჩვენი სხვა აპლიკაციების შემთხვევაში, ისინი შეგიძლიათ იხილოთ ფაილში. README.md საქაღალდეში sa-logic.

▍ კონტეინერირებული აპლიკაციების ტესტირება

შეგიძლიათ ენდოთ რაღაცას, რაც არ გამოგიცდიათ? მეც არ შემიძლია. მოდით შევამოწმოთ ჩვენი კონტეინერები.

დავიწყოთ განაცხადის კონტეინერი sa-logic და დააკონფიგურირეთ პორტზე მოსასმენად 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
დავიწყოთ განაცხადის კონტეინერი sa-webapp და დააკონფიგურირეთ პორტზე მოსასმენად 8080. გარდა ამისა, ჩვენ უნდა დავაყენოთ პორტი, რომელზეც Python აპლიკაცია მოუსმენს Java აპლიკაციის თხოვნებს გარემოს ცვლადის ხელახლა მინიჭებით. 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
```

იმის გასაგებად, თუ როგორ უნდა გაიგოთ კონტეინერის ან Docker VM-ის IP მისამართი, იხილეთ ფაილი README.

დავიწყოთ განაცხადის კონტეინერი sa-frontend:

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

ახლა ყველაფერი მზად არის ბრაუზერში ნავიგაციისთვის მისამართზე localhost:80 და შეამოწმეთ აპლიკაცია.

გთხოვთ გაითვალისწინოთ, რომ თუ შეცვლით პორტს sa-webapp, ან თუ თქვენ მართავთ Docker VM-ს, დაგჭირდებათ ფაილის რედაქტირება App.js საქაღალდიდან sa-frontendმეთოდით IP მისამართის ან პორტის ნომრის შეცვლით analyzeSentence()მოძველებული მონაცემების ნაცვლად მიმდინარე ინფორმაციის ჩანაცვლებით. ამის შემდეგ, თქვენ უნდა მოაწყოთ სურათი და გამოიყენოთ იგი.

ასე გამოიყურება ჩვენი განაცხადის დიაგრამა ახლა.

მიკროსერვისები მუშაობს კონტეინერებში

რეზიუმე: რატომ გვჭირდება Kubernetes კლასტერი?

ჩვენ ახლახან გადავხედეთ ფაილებს Dockerfile, ისაუბრა იმაზე, თუ როგორ უნდა შექმნათ სურათები და გადაიტანოთ ისინი Docker საცავში. გარდა ამისა, ვისწავლეთ როგორ დავაჩქაროთ სურათების შეკრება ფაილის გამოყენებით .dockerignore. შედეგად, ჩვენი მიკროსერვისები ახლა მუშაობს Docker კონტეინერებში. აქ შეიძლება გქონდეთ სრულიად გამართლებული შეკითხვა იმის შესახებ, თუ რატომ გვჭირდება Kubernetes. ამ კითხვაზე პასუხი დაეთმობა ამ მასალის მეორე ნაწილს. ამასობაში განიხილეთ შემდეგი კითხვა:
დავუშვათ, რომ ჩვენი ტექსტის ანალიზის ვებ აპლიკაცია პოპულარული გახდა მთელ მსოფლიოში. ყოველ წუთს მილიონობით მოთხოვნა მოდის მას. ეს ნიშნავს, რომ მიკროსერვისები sa-webapp и sa-logic იქნება უზარმაზარი სტრესის ქვეშ. როგორ გავაფართოვოთ კონტეინერები, რომლებიც ამუშავებენ მიკროსერვისებს?

წყარო: www.habr.com

Kubernetes-ის სახელმძღვანელო ნაწილი 1: აპლიკაციები, მიკროსერვისები და კონტეინერები