ការបង្រៀន Kubernetes ផ្នែកទី 1៖ កម្មវិធី សេវាមីក្រូ និងកុងតឺន័រ

តាមសំណើរបស់យើង Habr បានបង្កើតមជ្ឈមណ្ឌលមួយ។ Kubernetes ហើយយើងរីករាយក្នុងការដាក់ការបោះពុម្ពលើកដំបូងនៅក្នុងវា។ ជាវ!

Kubernetes គឺងាយស្រួល។ ហេតុអ្វីបានជាធនាគារបង់ប្រាក់ឱ្យខ្ញុំច្រើនដើម្បីធ្វើការនៅក្នុងតំបន់នេះ ខណៈពេលដែលនរណាម្នាក់អាចធ្វើជាម្ចាស់បច្ចេកវិទ្យានេះក្នុងរយៈពេលតែប៉ុន្មានម៉ោង?

ប្រសិនបើអ្នកសង្ស័យថា Kubernetes អាចរៀនបានយ៉ាងឆាប់រហ័ស ខ្ញុំស្នើឱ្យអ្នកព្យាយាមធ្វើវាដោយខ្លួនឯង។ មានន័យថា ដោយបានស្ទាត់ជំនាញសម្ភារៈនេះ អ្នកនឹងអាចដំណើរការកម្មវិធីដោយផ្អែកលើសេវាមីក្រូនៅក្នុងចង្កោម Kubernetes ។ ខ្ញុំអាចធានាបាន ព្រោះវាស្ថិតនៅក្នុងវិធីសាស្រ្តដូចគ្នាដែលខ្ញុំប្រើនៅទីនេះ ដែលខ្ញុំបង្រៀនអតិថិជនរបស់យើងពីរបៀបធ្វើការជាមួយ Kubernetes ។ តើអ្វីធ្វើឱ្យការណែនាំនេះខុសពីអ្នកដទៃ? តាមពិតរឿងជាច្រើន។ ដូច្នេះ សម្ភារៈទាំងនេះភាគច្រើនចាប់ផ្តើមដោយការពន្យល់អំពីរឿងសាមញ្ញ - គោលគំនិតរបស់ Kubernetes និងលក្ខណៈពិសេសនៃពាក្យបញ្ជា kubectl ។ អ្នកនិពន្ធនៃអត្ថបទទាំងនេះសន្មត់ថាអ្នកអានរបស់ពួកគេស៊ាំជាមួយការអភិវឌ្ឍន៍កម្មវិធី សេវាកម្មមីក្រូ និងកុងតឺន័រ Docker ។ យើងនឹងទៅវិធីផ្សេង។ ជាដំបូង សូមនិយាយអំពីរបៀបដំណើរការកម្មវិធីដោយផ្អែកលើ microservices នៅលើកុំព្យូទ័រ។ បន្ទាប់មកយើងនឹងពិនិត្យមើលការកសាងរូបភាពកុងតឺន័រសម្រាប់សេវាមីក្រូនីមួយៗ។ ហើយបន្ទាប់ពីនោះ យើងនឹងស្គាល់ Kubernetes និងវិភាគលើការដាក់ឱ្យប្រើប្រាស់កម្មវិធីដោយផ្អែកលើ microservices នៅក្នុងចង្កោមដែលគ្រប់គ្រងដោយ Kubernetes។

វិធីសាស្រ្តនេះ ជាមួយនឹងវិធីសាស្រ្តបន្តិចម្តងៗចំពោះ Kubernetes នឹងផ្តល់ឱ្យជម្រៅនៃការយល់ដឹងអំពីអ្វីដែលកំពុងកើតឡើងដែលមនុស្សជាមធ្យមត្រូវការ ដើម្បីយល់ពីរបៀបដែលអ្វីៗគ្រប់យ៉ាងត្រូវបានរៀបចំយ៉ាងសាមញ្ញនៅក្នុង Kubernetes ។ Kubernetes ពិត​ជា​បច្ចេកវិទ្យា​សាមញ្ញ​មួយ​ដែល​ផ្តល់​ថា​អ្នក​ណា​ដែល​ចង់​ស្ទាត់​ជំនាញ​វា​ដឹង​ពី​កន្លែង​និង​របៀប​ដែល​វា​ត្រូវ​បាន​ប្រើ។

ឥឡូវនេះ ដោយមិនមានការរំខានទៀតទេ ចូរយើងទៅធ្វើការ ហើយនិយាយអំពីកម្មវិធីដែលយើងនឹងធ្វើការជាមួយ។

កម្មវិធីពិសោធន៍

កម្មវិធីរបស់យើងនឹងអនុវត្តមុខងារតែមួយប៉ុណ្ណោះ។ វាត្រូវចំណាយពេលជាការបញ្ចូល ប្រយោគមួយ បន្ទាប់ពីនោះដោយប្រើឧបករណ៍វិភាគអត្ថបទ វាធ្វើការវិភាគមនោសញ្ចេតនានៃប្រយោគនេះ ដោយទទួលបានការវាយតម្លៃពីអាកប្បកិរិយាអារម្មណ៍របស់អ្នកនិពន្ធប្រយោគចំពោះវត្ថុជាក់លាក់មួយ។

នេះជាអ្វីដែលបង្អួចសំខាន់នៃកម្មវិធីនេះមើលទៅ។

កម្មវិធីបណ្តាញវិភាគអារម្មណ៍

តាមទស្សនៈបច្ចេកទេស កម្មវិធីមានមីក្រូសេវាចំនួនបី ដែលនីមួយៗអាចដោះស្រាយបញ្ហាមួយចំនួននៃភារកិច្ច៖

• SA-Frontend គឺជាម៉ាស៊ីនមេបណ្តាញ Nginx ដែលបម្រើឯកសារឋិតិវន្ត React ។
• SA-WebApp គឺជាកម្មវិធីគេហទំព័រដែលសរសេរក្នុង Java ដែលគ្រប់គ្រងសំណើពីផ្នែកខាងមុខ។
• SA-Logic គឺជាកម្មវិធី Python ដែលធ្វើការវិភាគមនោសញ្ចេតនា។

វាជាការសំខាន់ក្នុងការកត់សម្គាល់ថាសេវាមីក្រូមិនមាននៅក្នុងភាពឯកោទេ។ ពួកគេអនុវត្តគំនិតនៃ "ការបែងចែកភារកិច្ច" ប៉ុន្តែពួកគេក្នុងពេលតែមួយចាំបាច់ត្រូវធ្វើអន្តរកម្មគ្នាទៅវិញទៅមក។

លំហូរទិន្នន័យនៅក្នុងកម្មវិធី

នៅក្នុងដ្យាក្រាមខាងលើ អ្នកអាចមើលឃើញដំណាក់កាលលេខនៃប្រព័ន្ធ ដែលបង្ហាញពីលំហូរទិន្នន័យនៅក្នុងកម្មវិធី។ ចូរបំបែកពួកគេចុះ៖

1. កម្មវិធីរុករកស្នើសុំឯកសារពីម៉ាស៊ីនមេ index.html (ដែលនៅក្នុងវេនផ្ទុកកញ្ចប់កម្មវិធី React) ។
2. អ្នកប្រើប្រាស់ធ្វើអន្តរកម្មជាមួយកម្មវិធី នេះបណ្តាលឱ្យមានការហៅទៅកាន់កម្មវិធីបណ្តាញផ្អែកលើ Spring ។
3. កម្មវិធីបណ្តាញបញ្ជូនបន្តសំណើដើម្បីញែកអត្ថបទទៅកម្មវិធី Python ។
4. កម្មវិធី Python វិភាគអារម្មណ៍នៃអត្ថបទ ហើយត្រឡប់លទ្ធផលជាការឆ្លើយតបទៅនឹងសំណើ។
5. កម្មវិធី 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 - គ្មានអ្វីនឹងកើតឡើងទេ។ ប៉ុន្តែប្រសិនបើអ្នកក្រឡេកមើលកុងសូល អ្នកអាចឃើញសារកំហុសនៅទីនោះ។ ដើម្បីយល់ច្បាស់ពីកន្លែងដែលកំហុសទាំងនេះកើតឡើង ចូរយើងវិភាគកូដកម្មវិធី។

▍ ការវិភាគកូដនៃកម្មវិធីខាងមុខ

រកមើលលេខកូដឯកសារ 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 ។

យើងត្រូវការកម្មវិធី Spring ដែលអាចទទួលយកសំណើ POST

▍ ការដំឡើងកម្មវិធីបណ្តាញផ្អែកលើ Spring

ដើម្បីដាក់ឱ្យប្រើប្រាស់កម្មវិធី Spring អ្នកត្រូវការ JDK8 និង Maven និងអថេរបរិស្ថានដែលបានកំណត់យ៉ាងត្រឹមត្រូវ។ បន្ទាប់ពីអ្នកដំឡើងទាំងអស់នេះ អ្នកអាចបន្តធ្វើការលើគម្រោងរបស់យើង។

▍ ការវេចខ្ចប់កម្មវិធីទៅក្នុងឯកសារពាង

រុករក ដោយប្រើស្ថានីយទៅកាន់ថតឯកសារ 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();
    }
}

1. នៅក្នុង SentimentController មានវាលមួយ។ saLogicApiUrl. តម្លៃរបស់វាត្រូវបានកំណត់ដោយទ្រព្យសម្បត្តិ sa.logic.api.url.
2. បន្ទាត់ 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 អ្នកត្រូវតែដំឡើង 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

1. ការចាប់ផ្តើមវត្ថុ Flask.
2. បញ្ជាក់អាសយដ្ឋានសម្រាប់ធ្វើសំណើ POST ទៅវា។
3. ការទាញយកទ្រព្យសម្បត្តិ sentence ពីស្ថាប័នស្នើសុំ។
4. ការចាប់ផ្តើមវត្ថុអនាមិក TextBlob និងទទួលបានតម្លៃ polarity សម្រាប់សំណើដំបូងដែលបានទទួលនៅក្នុងតួនៃសំណើ (ក្នុងករណីរបស់យើង នេះគឺជាសំណើតែមួយគត់ដែលបានដាក់ជូនសម្រាប់ការវិភាគ)។
5. ត្រឡប់​ការ​ឆ្លើយ​តប តួ​អង្គ​ដែល​មាន​អត្ថបទ​នៃ​ការ​ផ្តល់​ជូន និង​សូចនាករ​ដែល​បាន​គណនា​សម្រាប់​វា។ polarity.
6. ការបើកដំណើរការកម្មវិធី Flask ដែលនឹងមាននៅ 0.0.0.0:5000 (អ្នកក៏អាចចូលប្រើវាដោយប្រើការស្ថាបនាទម្រង់ localhost:5000).

ឥឡូវនេះ សេវាមីក្រូដែលបង្កើតកម្មវិធីកំពុងដំណើរការ។ ពួកគេត្រូវបានកំណត់ដើម្បីធ្វើអន្តរកម្មគ្នាទៅវិញទៅមក។ នេះគឺជាអ្វីដែលដ្យាក្រាមកម្មវិធីមើលទៅដូចនៅដំណាក់កាលនៃការងារនេះ។

សេវាមីក្រូទាំងអស់ដែលបង្កើតកម្មវិធីត្រូវបាននាំយកទៅស្ថានភាពដែលមានសុខភាពល្អ

ឥឡូវនេះ មុនពេលយើងបន្ត សូមបើកកម្មវិធី React នៅក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិត ហើយព្យាយាមញែកប្រយោគមួយចំនួនជាមួយវា។ ប្រសិនបើអ្វីៗគ្រប់យ៉ាងត្រូវបានធ្វើបានត្រឹមត្រូវ - បន្ទាប់ពីចុចប៊ូតុង Send អ្នកនឹងឃើញលទ្ធផលវិភាគខាងក្រោមប្រអប់អត្ថបទ។

នៅក្នុងផ្នែកបន្ទាប់ យើងនឹងនិយាយអំពីរបៀបដំណើរការសេវាកម្មមីក្រូរបស់យើងនៅក្នុង Docker containers។ នេះគឺចាំបាច់ដើម្បីរៀបចំកម្មវិធីឱ្យដំណើរការនៅក្នុងចង្កោម Kubernetes ។

ធុង Docker

Kubernetes គឺជាប្រព័ន្ធសម្រាប់ស្វ័យប្រវត្តិកម្មនៃការដាក់ពង្រាយ ការធ្វើមាត្រដ្ឋាន និងការគ្រប់គ្រងកម្មវិធីកុងតឺន័រ។ វាត្រូវបានគេហៅផងដែរថា "វង់ភ្លេងកុងតឺន័រ" ។ ប្រសិនបើ Kubernetes ដំណើរការជាមួយកុងតឺន័រ នោះមុននឹងប្រើប្រព័ន្ធនេះ យើងត្រូវទទួលបានធុងទាំងនេះជាមុនសិន។ ប៉ុន្តែដំបូងសូមនិយាយអំពីអ្វីដែលធុង។ ប្រហែលជាចម្លើយដ៏ល្អបំផុតចំពោះសំណួរនៃអ្វីដែលវាគឺអាចរកបាននៅក្នុង ឯកសារ ទៅ Docker៖

រូបភាពកុងតឺន័រគឺជាកញ្ចប់ប្រតិបត្តិដែលមានទម្ងន់ស្រាល ផ្ទុកដោយខ្លួនឯង ដែលមានកម្មវិធី ដែលរួមបញ្ចូលអ្វីៗគ្រប់យ៉ាងដែលចាំបាច់សម្រាប់ដំណើរការវា៖ កូដកម្មវិធី បរិយាកាសពេលដំណើរការ ឧបករណ៍ប្រព័ន្ធ និងបណ្ណាល័យ ការកំណត់។ កម្មវិធីដែលមានកុងតឺន័រអាចប្រើប្រាស់បានទាំងនៅក្នុងបរិស្ថាន Linux និង Windows ហើយនឹងដំណើរការដូចគ្នាជានិច្ចដោយមិនគិតពីហេដ្ឋារចនាសម្ព័ន្ធ។

នេះមានន័យថាកុងតឺន័រអាចដំណើរការលើកុំព្យូទ័រណាមួយ រួមទាំងម៉ាស៊ីនមេផលិតកម្ម ហើយនៅក្នុងបរិយាកាសណាមួយ កម្មវិធីដែលមាននៅក្នុងពួកវានឹងដំណើរការដូចគ្នាដែរ។

ដើម្បីស្វែងយល់ពីលក្ខណៈពិសេសរបស់កុងតឺន័រ ហើយប្រៀបធៀបពួកវាទៅនឹងវិធីផ្សេងទៀតដើម្បីដំណើរការកម្មវិធី សូមមើលឧទាហរណ៍នៃការបម្រើកម្មវិធី React ដោយប្រើម៉ាស៊ីននិម្មិត និងកុងតឺន័រ។

▍ បម្រើឯកសារឋិតិវន្តនៃកម្មវិធី React ដោយប្រើម៉ាស៊ីននិម្មិត

ការព្យាយាមរៀបចំការថែទាំឯកសារឋិតិវន្តដោយប្រើម៉ាស៊ីននិម្មិត យើងនឹងជួបប្រទះនូវគុណវិបត្តិដូចខាងក្រោម៖

1. ការប្រើប្រាស់ធនធានមិនមានប្រសិទ្ធភាព ដោយសារម៉ាស៊ីននិម្មិតនីមួយៗគឺជាប្រព័ន្ធប្រតិបត្តិការពេញលេញ។
2. ភាពអាស្រ័យនៃវេទិកា។ អ្វី​ដែល​ដំណើរការ​លើ​កុំព្យូទ័រ​ក្នុង​ស្រុក​មួយ​ចំនួន​ប្រហែល​ជា​មិន​ដំណើរការ​នៅ​លើ​ម៉ាស៊ីន​បម្រើ​ផលិតកម្ម​ទេ។
3. ការធ្វើមាត្រដ្ឋានយឺត និងពឹងផ្អែកធនធាននៃដំណោះស្រាយម៉ាស៊ីននិម្មិត។

ម៉ាស៊ីនមេបណ្តាញ Nginx បម្រើឯកសារឋិតិវន្តដែលកំពុងដំណើរការក្នុងម៉ាស៊ីននិម្មិត

ប្រសិនបើកុងតឺន័រត្រូវបានប្រើដើម្បីដោះស្រាយបញ្ហាស្រដៀងគ្នានោះ បើប្រៀបធៀបជាមួយម៉ាស៊ីននិម្មិត ភាពខ្លាំងខាងក្រោមអាចត្រូវបានគេកត់សម្គាល់ឃើញ៖

1. ការប្រើប្រាស់ធនធានប្រកបដោយប្រសិទ្ធភាព៖ ធ្វើការជាមួយប្រព័ន្ធប្រតិបត្តិការដោយប្រើ Docker ។
2. ឯករាជ្យភាពនៃវេទិកា។ កុងតឺន័រដែលអ្នកអភិវឌ្ឍន៍អាចដំណើរការលើកុំព្យូទ័ររបស់ពួកគេផ្ទាល់នឹងដំណើរការគ្រប់ទីកន្លែង។
3. ការដាក់ពង្រាយទម្ងន់ស្រាលតាមរយៈការប្រើប្រាស់ស្រទាប់រូបភាព។

ម៉ាស៊ីនមេបណ្តាញ Nginx បម្រើឯកសារឋិតិវន្តដែលកំពុងដំណើរការក្នុងកុងតឺន័រ

យើងបានប្រៀបធៀបតែម៉ាស៊ីននិម្មិត និងកុងតឺន័រលើចំណុចមួយចំនួនប៉ុណ្ណោះ ប៉ុន្តែសូម្បីតែវាគ្រប់គ្រាន់ដើម្បីទទួលបាននូវអារម្មណ៍សម្រាប់ភាពខ្លាំងនៃធុង។ វាគឺជាការ អ្នកអាចស្វែងរកព័ត៌មានលម្អិតអំពីធុង Docker ។

▍ ការបង្កើតរូបភាពកុងតឺន័រសម្រាប់កម្មវិធី React

ប្លុកអគារមូលដ្ឋាននៃធុង Docker គឺជាឯកសារ Dockerfile. នៅដើមឯកសារនេះ រូបភាពមូលដ្ឋាននៃកុងតឺន័រត្រូវបានកត់ត្រា បន្ទាប់មកលំដាប់នៃការណែនាំត្រូវបានរួមបញ្ចូលដែលបង្ហាញពីរបៀបបង្កើតកុងតឺន័រដែលនឹងបំពេញតម្រូវការរបស់កម្មវិធី។

មុនពេលយើងចាប់ផ្តើមធ្វើការជាមួយឯកសារ Dockerfileចងចាំនូវអ្វីដែលយើងបានធ្វើដើម្បីរៀបចំឯកសារនៃកម្មវិធី React សម្រាប់ផ្ទុកឡើងទៅកាន់ម៉ាស៊ីនមេ Nginx៖

1. ការកសាងកញ្ចប់កម្មវិធី React (npm run build).
2. ចាប់ផ្តើមម៉ាស៊ីនមេ Nginx ។
3. ការចម្លងមាតិកានៃថតឯកសារ build ពីថតគម្រោង sa-frontend ទៅថតម៉ាស៊ីនមេ nginx/html.

ខាងក្រោមនេះ អ្នកអាចមើលឃើញភាពស្របគ្នារវាងការបង្កើតកុងតឺន័រ និងសកម្មភាពខាងលើដែលបានអនុវត្តនៅលើកុំព្យូទ័រមូលដ្ឋាន។

▍ កំពុងរៀបចំ Dockerfile សម្រាប់កម្មវិធី SA-Frontend

សេចក្តីណែនាំដែលត្រូវបញ្ចូលក្នុង Dockerfile សម្រាប់ពាក្យសុំ SA-Frontendមានពាក្យបញ្ជាតែពីរប៉ុណ្ណោះ។ ការពិតគឺថាក្រុមអភិវឌ្ឍន៍ Nginx បានរៀបចំមូលដ្ឋាន រូបភាពមួយ សម្រាប់ Nginx ដែលយើងនឹងប្រើដើម្បីបង្កើតរូបភាពរបស់យើង។ នេះគឺជាជំហានពីរដែលយើងត្រូវពណ៌នា៖

1. អ្នកត្រូវធ្វើឱ្យរូបភាព Nginx ជាមូលដ្ឋាននៃរូបភាព។
2. មាតិកាថតឯកសារ 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 ។ នៅដំណាក់កាលនៃការងារនេះ អ្នកត្រូវធ្វើដូចខាងក្រោមៈ

1. ដំឡើង Dockers.
2. ចុះឈ្មោះនៅលើគេហទំព័រ Docker Hub ។
3. ចូលទៅគណនីរបស់អ្នកដោយដំណើរការពាក្យបញ្ជាខាងក្រោមនៅក្នុងស្ថានីយ៖

   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. ដើម្បីស្វែងរកអាសយដ្ឋាន IP របស់ម៉ាស៊ីននិម្មិត Docker អ្នកអាចប្រើពាក្យបញ្ជា docker-machine ip.

នៅចំណុចនេះ នៅពេលដែលឧបករណ៍ផ្ទុកកម្មវិធីផ្នែកខាងមុខបានចាប់ផ្តើមដំណើរការដោយជោគជ័យ អ្នកគួរតែអាចបើកទំព័ររបស់វានៅក្នុងកម្មវិធីរុករកបាន។

ឯកសារ ▍.dockerignore

ការបង្កើតរូបភាពកម្មវិធី SA-Frontendយើងអាចកត់សំគាល់ថាដំណើរការនេះគឺយឺតខ្លាំងណាស់។ នេះគឺដោយសារតែបរិបទបង្កើតរូបភាពត្រូវតែផ្ញើទៅដេមិន Docker ។ ថតដែលតំណាងឱ្យបរិបទស្ថាបនាត្រូវបានផ្តល់ជាអាគុយម៉ង់ចុងក្រោយចំពោះពាក្យបញ្ជា 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.

▍ ការបង្កើតរូបភាពកុងតឺន័រសម្រាប់កម្មវិធី Python

ប្រសិនបើអ្នកក្រឡេកមើលខ្លឹមសារនៃឯកសារ Dockerfile ក្នុងថតឯកសារ sa-logicអ្នកនឹងមិនរកឃើញអ្វីថ្មីនៅទីនោះទេ។ ពាក្យ​បញ្ជា​សម្រាប់​ការ​បង្កើត​រូបភាព និង​រុញ​វា​ទៅ​ឃ្លាំង​គួរតែ​ធ្លាប់​ស្គាល់​អ្នក​រួច​ហើយ ប៉ុន្តែ​ដូច​ជា​នៅ​ក្នុង​ករណី​នៃ​កម្មវិធី​ផ្សេង​ទៀត​របស់​យើង ពួកវា​អាច​រក​ឃើញ​ក្នុង​ឯកសារ README.md ក្នុងថតឯកសារ sa-logic.

▍ សាកល្បងកម្មវិធីដាក់ធុង

តើអ្នកអាចជឿជាក់លើអ្វីមួយដែលអ្នកមិនទាន់បានសាកល្បងទេ? ខ្ញុំក៏មិនអាចដែរ។ តោះសាកល្បងធុងរបស់យើង។

1. តោះចាប់ផ្តើមធុងកម្មវិធី sa-logic ហើយកំណត់រចនាសម្ព័ន្ធវាដើម្បីស្តាប់នៅលើច្រក 5050:

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

2. តោះចាប់ផ្តើមធុងកម្មវិធី 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

ដើម្បីស្វែងយល់ពីរបៀបស្វែងរកអាសយដ្ឋាន IP របស់កុងតឺន័រ ឬ Docker VM សូមមើលឯកសារ 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 containers។ នៅទីនេះ អ្នកប្រហែលជាមានសំណួរសមហេតុផលទាំងស្រុងអំពីមូលហេតុដែលយើងត្រូវការ Kubernetes ។ ចម្លើយចំពោះសំណួរនេះនឹងត្រូវបានឧទ្ទិសដល់ផ្នែកទីពីរនៃសម្ភារៈនេះ។ ក្នុងពេលនេះ សូមពិចារណាសំណួរខាងក្រោម៖
ចូរសន្មតថាកម្មវិធីគេហទំព័រការវិភាគអត្ថបទរបស់យើងបានក្លាយទៅជាការពេញនិយមទូទាំងពិភពលោក។ សំណើរាប់លានមករកគាត់រាល់នាទី។ នេះមានន័យថាសេវាមីក្រូ sa-webapp и sa-logic នឹងស្ថិតនៅក្រោមភាពតានតឹងដ៏ធំសម្បើម។ របៀបធ្វើមាត្រដ្ឋានធុងដែលដំណើរការមីក្រូសេវាកម្ម?

ប្រភព: www.habr.com