🥇 Tarantool Cartridge: Lua backend sharding ជាបីបន្ទាត់

យើងនៅ Mail.ru Group មាន Tarantool - នេះគឺជាម៉ាស៊ីនមេកម្មវិធីនៅក្នុង Lua ដែលជាមូលដ្ឋានទិន្នន័យរួមបញ្ចូលគ្នា (ឬផ្ទុយមកវិញ?) ។ វាលឿន និងត្រជាក់ ប៉ុន្តែលទ្ធភាពនៃម៉ាស៊ីនមេតែមួយនៅតែមិនមានដែនកំណត់។ ការធ្វើមាត្រដ្ឋានបញ្ឈរក៏មិនមែនជា panacea ដែរ ដូច្នេះ Tarantool មានឧបករណ៍សម្រាប់ធ្វើមាត្រដ្ឋានផ្ដេក — ម៉ូឌុល vshard [1]. វាអនុញ្ញាតឱ្យអ្នកបំបែកទិន្នន័យនៅលើម៉ាស៊ីនមេជាច្រើន ប៉ុន្តែអ្នកត្រូវគិតគូរជាមួយវា ដើម្បីរៀបចំវា និងស្វែងរកតក្កវិជ្ជាអាជីវកម្ម។

ដំណឹងល្អ៖ យើងបានប្រមូលកោណ (ឧទាហរណ៍ [2], [3]) និងបានដាក់ក្របខណ្ឌមួយផ្សេងទៀតដែលនឹងសម្រួលយ៉ាងសំខាន់នូវដំណោះស្រាយនៃបញ្ហានេះ។

ប្រអប់ព្រីនធឺរ គឺជាក្របខ័ណ្ឌថ្មីមួយសម្រាប់ការបង្កើតប្រព័ន្ធចែកចាយស្មុគស្មាញ។ វាអនុញ្ញាតឱ្យអ្នកផ្តោតលើការសរសេរតក្កវិជ្ជាអាជីវកម្មជំនួសឱ្យការដោះស្រាយបញ្ហាហេដ្ឋារចនាសម្ព័ន្ធ។ នៅក្រោមការកាត់ ខ្ញុំនឹងប្រាប់អ្នកពីរបៀបដែលក្របខ័ណ្ឌនេះដំណើរការ និងរបៀបសរសេរសេវាចែកចាយជាមួយវា។

ហើយតើអ្វីជាបញ្ហា?

យើងមាន tarantula យើងមាន vshard - តើអ្នកចង់បានអ្វីទៀត?

ទីមួយវាជាបញ្ហានៃភាពងាយស្រួល។ ការកំណត់រចនាសម្ព័ន្ធ vshard ត្រូវបានកំណត់រចនាសម្ព័ន្ធតាមរយៈតារាង Lua ។ សម្រាប់ប្រព័ន្ធចែកចាយនៃដំណើរការ Tarantool ច្រើនដើម្បីដំណើរការបានត្រឹមត្រូវ ការកំណត់រចនាសម្ព័ន្ធត្រូវតែដូចគ្នានៅគ្រប់ទីកន្លែង។ គ្មាននរណាម្នាក់ចង់ធ្វើវាដោយដៃទេ។ ដូច្នេះ ស្គ្រីបគ្រប់ប្រភេទ Ansible ប្រព័ន្ធដាក់ពង្រាយត្រូវបានប្រើប្រាស់។

Cartridge គ្រប់គ្រងការកំណត់រចនាសម្ព័ន្ធ vshard ដោយខ្លួនវា វាធ្វើវាដោយផ្អែកលើវាផ្ទាល់ ការកំណត់រចនាសម្ព័ន្ធចែកចាយផ្ទាល់ខ្លួន. ជាទូទៅ វាជាឯកសារ YAML សាមញ្ញ ដែលច្បាប់ចម្លងត្រូវបានរក្សាទុកនៅក្នុងគ្រប់ករណីរបស់ Tarantool ។ ភាពសាមញ្ញស្ថិតនៅក្នុងការពិតដែលថាក្របខ័ណ្ឌខ្លួនវាត្រួតពិនិត្យការកំណត់រចនាសម្ព័ន្ធរបស់វា ហើយធានាថាវាដូចគ្នានៅគ្រប់ទីកន្លែង។

ទីពីរ វាជាបញ្ហានៃភាពងាយស្រួលម្តងទៀត។ ការកំណត់រចនាសម្ព័ន្ធ vshard មិនមានអ្វីដែលត្រូវធ្វើជាមួយការអភិវឌ្ឍន៍តក្កវិជ្ជាអាជីវកម្មទេ ហើយគ្រាន់តែរំខានអ្នកសរសេរកម្មវិធីពីការងារប៉ុណ្ណោះ។ នៅពេលយើងពិភាក្សាអំពីស្ថាបត្យកម្មនៃគម្រោង ភាគច្រើនយើងកំពុងនិយាយអំពីធាតុផ្សំនីមួយៗ និងអន្តរកម្មរបស់ពួកគេ។ វាលឿនពេកក្នុងការគិតអំពីការដាក់ចេញនូវចង្កោមសម្រាប់មជ្ឈមណ្ឌលទិន្នន័យចំនួន 3 ។

យើងបានដោះស្រាយបញ្ហាទាំងនេះម្តងម្កាល ហើយនៅចំណុចខ្លះ យើងអាចបង្កើតវិធីសាស្រ្តដែលអនុញ្ញាតឱ្យយើងសម្រួលការងារជាមួយកម្មវិធីពេញមួយវដ្តជីវិតរបស់វា៖ ការបង្កើត ការអភិវឌ្ឍន៍ ការធ្វើតេស្ត CI/CD ការថែទាំ។

Cartridge ណែនាំគោលគំនិតនៃតួនាទីសម្រាប់ដំណើរការ Tarantool នីមួយៗ។ តួនាទីគឺជាគំនិតដែលអនុញ្ញាតឱ្យអ្នកអភិវឌ្ឍន៍ផ្តោតលើការសរសេរកូដ។ តួនាទីទាំងអស់ដែលមាននៅក្នុងគម្រោងអាចដំណើរការលើឧទាហរណ៍តែមួយនៃ Tarantool ហើយវានឹងគ្រប់គ្រាន់សម្រាប់ការធ្វើតេស្ត។

លក្ខណៈសំខាន់ៗរបស់ តារ៉ាន់ធូល ព្រីនធឺរ៖

ការរៀបចំចង្កោមដោយស្វ័យប្រវត្តិ;
ការពង្រីកមុខងារកម្មវិធីជាមួយនឹងតួនាទីថ្មី;
គំរូកម្មវិធីសម្រាប់ការអភិវឌ្ឍ និងការដាក់ឱ្យប្រើប្រាស់;
ការបំបែកដោយស្វ័យប្រវត្តិដែលភ្ជាប់មកជាមួយ;
ការរួមបញ្ចូលជាមួយក្របខ័ណ្ឌការធ្វើតេស្ត Luatest;
ការគ្រប់គ្រងចង្កោមដោយប្រើ WebUI និង API;
ឧបករណ៍វេចខ្ចប់ និងដាក់ឱ្យប្រើប្រាស់។

សួស្តីពិភពលោក!

ខ្ញុំមិនអាចរង់ចាំបង្ហាញក្របខណ្ឌដោយខ្លួនឯងបានទេ ដូច្នេះយើងនឹងទុករឿងអំពីស្ថាបត្យកម្មនៅពេលក្រោយ ហើយចាប់ផ្តើមសាមញ្ញ។ ដោយសន្មតថា Tarantool ខ្លួនវាត្រូវបានដំឡើងរួចហើយ រឿងតែមួយគត់ដែលត្រូវធ្វើគឺ

$ tarantoolctl rocks install cartridge-cli
$ export PATH=$PWD/.rocks/bin/:$PATH

ពាក្យបញ្ជាទាំងពីរនេះនឹងដំឡើងឧបករណ៍ប្រើប្រាស់បន្ទាត់ពាក្យបញ្ជា និងអនុញ្ញាតឱ្យអ្នកបង្កើតកម្មវិធីដំបូងរបស់អ្នកពីគំរូ៖

$ cartridge create --name myapp

ហើយនេះគឺជាអ្វីដែលយើងទទួលបាន៖

myapp/
├── .git/
├── .gitignore
├── app/roles/custom.lua
├── deps.sh
├── init.lua
├── myapp-scm-1.rockspec
├── test
│   ├── helper
│   │   ├── integration.lua
│   │   └── unit.lua
│   ├── helper.lua
│   ├── integration/api_test.lua
│   └── unit/sample_test.lua
└── tmp/

នេះគឺជាឃ្លាំង git ជាមួយ "ជំរាបសួរពិភពលោក!" កម្មវិធី។ តោះព្យាយាមដំណើរការវាភ្លាមៗ បន្ទាប់ពីដំឡើងភាពអាស្រ័យ (រួមទាំងក្របខ័ណ្ឌខ្លួនឯង)៖

$ tarantoolctl rocks make
$ ./init.lua --http-port 8080

ដូច្នេះ យើងមានថ្នាំងមួយនៃកម្មវិធី sharded នាពេលអនាគតដែលកំពុងដំណើរការ។ បុគ្គលិកដែលចង់ដឹងចង់ឃើញអាចបើកចំណុចប្រទាក់បណ្ដាញភ្លាមៗ កំណត់រចនាសម្ព័ន្ធចង្កោមពីថ្នាំងមួយដោយប្រើកណ្តុរ ហើយរីករាយនឹងលទ្ធផល ប៉ុន្តែវាលឿនពេកក្នុងការរីករាយ។ រហូតមកដល់ពេលនេះកម្មវិធីមិនដឹងពីរបៀបធ្វើអ្វីដែលមានប្រយោជន៍ទេដូច្នេះខ្ញុំនឹងនិយាយអំពីការដាក់ពង្រាយនៅពេលក្រោយហើយឥឡូវនេះវាដល់ពេលដែលត្រូវសរសេរកូដ។

ការអភិវឌ្ន៍កម្មវិធី

គ្រាន់តែស្រមៃ យើងកំពុងរចនាគម្រោងដែលគួរទទួលទិន្នន័យ រក្សាទុកវា និងបង្កើតរបាយការណ៍ម្តងក្នុងមួយថ្ងៃ។

យើងចាប់ផ្តើមគូរដ្យាក្រាម ហើយដាក់ធាតុផ្សំបីនៅលើវា៖ ច្រកផ្លូវ កន្លែងផ្ទុក និងកម្មវិធីកំណត់ពេល។ យើងកំពុងធ្វើការលើស្ថាបត្យកម្ម។ ដោយសារយើងប្រើ vshard ជាកន្លែងផ្ទុក យើងបន្ថែម vshard-router និង vshard-storage ទៅក្នុងគ្រោងការណ៍។ ទាំងច្រកផ្លូវ ឬកម្មវិធីកំណត់ពេលនឹងចូលប្រើកន្លែងផ្ទុកដោយផ្ទាល់ មានរ៉ោតទ័រសម្រាប់វា វាត្រូវបានបង្កើតឡើងសម្រាប់រឿងនេះ។

ដ្យាក្រាមនេះនៅតែមិនឆ្លុះបញ្ចាំងយ៉ាងត្រឹមត្រូវអំពីអ្វីដែលយើងនឹងបង្កើតនៅក្នុងគម្រោងនោះទេ ពីព្រោះធាតុផ្សំមើលទៅអរូបី។ យើងនៅតែត្រូវមើលពីរបៀបដែលវាត្រូវបានព្យាករនៅលើ Tarantool ពិតប្រាកដ - ចូរយើងដាក់ជាក្រុមសមាសធាតុរបស់យើងតាមដំណើរការ។

វាសមហេតុផលតិចតួចក្នុងការរក្សា vshard-router និង gateway នៅលើករណីដាច់ដោយឡែក។ ហេតុអ្វីបានជាយើងត្រូវឆ្លងកាត់បណ្តាញម្តងទៀត ប្រសិនបើនេះជាទំនួលខុសត្រូវរបស់រ៉ោតទ័រ? ពួកគេត្រូវតែដំណើរការក្នុងដំណើរការដូចគ្នា។ នោះគឺទាំង gateway និង vshard.router.cfg ត្រូវបានចាប់ផ្តើមនៅក្នុងដំណើរការមួយ ហើយអនុញ្ញាតឱ្យពួកវាធ្វើអន្តរកម្មក្នុងមូលដ្ឋាន។

នៅដំណាក់កាលរចនា វាងាយស្រួលក្នុងការធ្វើការជាមួយសមាសភាគបី ប៉ុន្តែក្នុងនាមជាអ្នកអភិវឌ្ឍន៍ ខណៈពេលកំពុងសរសេរកូដ ខ្ញុំមិនចង់គិតអំពីការដំណើរការបីឧទាហរណ៍នៃ Tarnatool ទេ។ ខ្ញុំត្រូវដំណើរការតេស្ត ហើយពិនិត្យមើលថាខ្ញុំសរសេរ gateway ត្រឹមត្រូវ។ ឬប្រហែលជាខ្ញុំចង់បង្ហាញលក្ខណៈពិសេសមួយដល់សហសេវិករបស់ខ្ញុំ។ ហេតុអ្វីបានជាខ្ញុំគួររំខានជាមួយនឹងការដាក់ពង្រាយករណីបី? នេះជារបៀបដែលគំនិតនៃតួនាទីបានកើតមក។ តួនាទីគឺជាម៉ូឌុល lush ធម្មតា វដ្តជីវិតដែលគ្រប់គ្រងដោយ Cartridge ។ ក្នុងឧទាហរណ៍នេះមានបួនក្នុងចំណោមពួកគេ - ច្រកផ្លូវ, រ៉ោតទ័រ, ការផ្ទុក, កម្មវិធីកំណត់ពេល។ អាចមានច្រើនទៀតនៅក្នុងគម្រោងមួយផ្សេងទៀត។ តួនាទីទាំងអស់អាចដំណើរការក្នុងដំណើរការតែមួយ ហើយវាគ្រប់គ្រាន់ហើយ។

ហើយនៅពេលដែលវាមកដល់ការដាក់ពង្រាយដល់ដំណាក់កាល ឬការផលិត នោះយើងនឹងចាត់ចែងដំណើរការ Tarantool នីមួយៗនូវតួនាទីរបស់វាអាស្រ័យលើសមត្ថភាពផ្នែករឹង៖

ការគ្រប់គ្រង Topology

ព័ត៌មានអំពីកន្លែងដែលតួនាទីកំពុងដំណើរការត្រូវតែរក្សាទុកនៅកន្លែងណាមួយ។ ហើយ "កន្លែងណាមួយ" នេះគឺជាការកំណត់រចនាសម្ព័ន្ធចែកចាយ ដែលខ្ញុំបានរៀបរាប់ខាងលើរួចហើយ។ អ្វីដែលសំខាន់បំផុតនៅក្នុងវាគឺ topology នៃចង្កោម។ នេះគឺជាក្រុមចម្លងចំនួន 3 នៃដំណើរការ Tarantool ចំនួន 5៖

យើងមិនចង់បាត់បង់ទិន្នន័យ ដូច្នេះយើងយកចិត្តទុកដាក់លើព័ត៌មានអំពីដំណើរការដែលកំពុងដំណើរការ។ Cartridge រក្សាដាននៃការកំណត់រចនាសម្ព័ន្ធជាមួយនឹងការប្តេជ្ញាចិត្តពីរដំណាក់កាល។ ដរាបណាយើងចង់ធ្វើបច្ចុប្បន្នភាពការកំណត់រចនាសម្ព័ន្ធ ជាដំបូងវាពិនិត្យថាគ្រប់ករណីទាំងអស់គឺអាចរកបាន និងរួចរាល់ដើម្បីទទួលយកការកំណត់ថ្មី។ បន្ទាប់ពីនោះដំណាក់កាលទីពីរអនុវត្តការកំណត់។ ដូច្នេះ ទោះបីជាច្បាប់ចម្លងមួយច្បាប់មិនអាចប្រើបានបណ្ដោះអាសន្នក៏ដោយ ក៏គ្មានអ្វីអាក្រក់កើតឡើងដែរ។ ការកំណត់រចនាសម្ព័ន្ធនឹងមិនអនុវត្តទេ ហើយអ្នកនឹងឃើញកំហុសជាមុន។

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

ជីវិតនៃតួនាទី

ដើម្បីឱ្យតួនាទីអរូបីមាននៅក្នុងស្ថាបត្យកម្មបែបនេះ ក្របខ័ណ្ឌត្រូវតែគ្រប់គ្រងពួកវាតាមរបៀបណាមួយ។ តាមធម្មជាតិ ការគ្រប់គ្រងកើតឡើងដោយមិនចាប់ផ្តើមដំណើរការ Tarantool ឡើងវិញ។ មានការហៅត្រឡប់មកវិញចំនួន 4 សម្រាប់ការគ្រប់គ្រងតួនាទី។ Cartridge ខ្លួនវានឹងហៅពួកវាអាស្រ័យលើអ្វីដែលវាបានសរសេរនៅក្នុងការកំណត់រចនាសម្ព័ន្ធចែកចាយ ដោយហេតុនេះអនុវត្តការកំណត់រចនាសម្ព័ន្ធទៅតួនាទីជាក់លាក់។

function init()
function validate_config()
function apply_config()
function stop()

តួនាទីនីមួយៗមានមុខងារ init. វាត្រូវបានហៅម្តងនៅពេលដែលតួនាទីត្រូវបានបើក ឬនៅពេលដែល Tarantool ត្រូវបានចាប់ផ្តើមឡើងវិញ។ នៅទីនោះវាងាយស្រួល ជាឧទាហរណ៍ ដើម្បីចាប់ផ្តើម box.space.create ឬកម្មវិធីកំណត់ពេលអាចចាប់ផ្តើមសរសៃផ្ទៃខាងក្រោយមួយចំនួនដែលនឹងដំណើរការនៅចន្លោះពេលជាក់លាក់។

មុខងារតែមួយ init ប្រហែលជាមិនគ្រប់គ្រាន់ទេ។ Cartridge អនុញ្ញាតឱ្យតួនាទីទាញយកអត្ថប្រយោជន៍នៃការកំណត់រចនាសម្ព័ន្ធចែកចាយដែលវាប្រើដើម្បីរក្សាទុក topology ។ យើងអាចប្រកាសផ្នែកថ្មីនៅក្នុងការកំណត់រចនាសម្ព័ន្ធដូចគ្នា និងរក្សាទុកបំណែកនៃការកំណត់រចនាសម្ព័ន្ធអាជីវកម្មនៅក្នុងវា។ ក្នុងឧទាហរណ៍របស់ខ្ញុំ នេះអាចជាគ្រោងការណ៍ទិន្នន័យ ឬការកំណត់កាលវិភាគសម្រាប់តួនាទីអ្នកកំណត់ពេល។

ការហៅជាក្រុម validate_config и apply_config រាល់ពេលដែលការកំណត់រចនាសម្ព័ន្ធចែកចាយផ្លាស់ប្តូរ។ នៅពេលដែលការកំណត់រចនាសម្ព័ន្ធត្រូវបានអនុវត្តដោយការប្តេជ្ញាចិត្តពីរដំណាក់កាល ចង្កោមពិនិត្យមើលថាតួនាទីនីមួយៗបានត្រៀមខ្លួនរួចរាល់ហើយក្នុងការទទួលយកការកំណត់រចនាសម្ព័ន្ធថ្មីនេះ ហើយរាយការណ៍អំពីកំហុសទៅកាន់អ្នកប្រើប្រាស់ប្រសិនបើចាំបាច់។ នៅពេលដែលមនុស្សគ្រប់គ្នាយល់ស្របថាការកំណត់រចនាសម្ព័ន្ធគឺធម្មតាបន្ទាប់មក apply_config.

តួនាទីក៏មានវិធីសាស្រ្តផងដែរ។ stopដែលត្រូវការដើម្បីសម្អាតតួនាទីសំខាន់។ ប្រសិនបើយើងនិយាយថាកម្មវិធីកំណត់ពេលលែងត្រូវការនៅលើម៉ាស៊ីនមេនេះ វាអាចបញ្ឈប់សរសៃទាំងនោះដែលវាបានចាប់ផ្តើមជាមួយ init.

តួនាទីអាចទាក់ទងគ្នាទៅវិញទៅមក។ យើងធ្លាប់ប្រើដើម្បីសរសេរការហៅមុខងារនៅក្នុង Lua ប៉ុន្តែវាអាចនឹងកើតឡើងដែលនៅក្នុងដំណើរការនេះមិនមានតួនាទីដែលយើងត្រូវការនោះទេ។ ដើម្បីជួយសម្រួលដល់ការហៅទូរសព្ទតាមបណ្តាញ យើងប្រើម៉ូឌុលជំនួយ rpc (ការហៅតាមនីតិវិធីពីចម្ងាយ) ដែលត្រូវបានបង្កើតឡើងនៅលើមូលដ្ឋាននៃ netbox ស្តង់ដារដែលបានបង្កើតឡើងនៅក្នុង Tarantool ។ វាអាចមានប្រយោជន៍ ប្រសិនបើជាឧទាហរណ៍ ច្រកផ្លូវរបស់អ្នកចង់សួរអ្នកកំណត់ពេលដោយផ្ទាល់ឱ្យធ្វើការងារនៅពេលនេះ ជាជាងរង់ចាំមួយថ្ងៃ។

ចំណុចសំខាន់មួយទៀតគឺធានាការអត់ឱនចំពោះកំហុស។ Cartridge ប្រើពិធីការ SWIM ដើម្បីតាមដានសុខភាព [4]. និយាយឱ្យខ្លី ដំណើរការផ្លាស់ប្តូរ "ពាក្យចចាមអារ៉ាម" គ្នាទៅវិញទៅមកលើ UDP - ដំណើរការនីមួយៗប្រាប់អ្នកជិតខាងរបស់ខ្លួនអំពីព័ត៌មានចុងក្រោយ ហើយពួកគេឆ្លើយតប។ ប្រសិនបើភ្លាមៗនោះចម្លើយមិនបានមក Tarantool ចាប់ផ្តើមសង្ស័យថាមានអ្វីមួយខុសហើយបន្ទាប់ពីមួយរយៈពេលគាត់បានសូត្រសេចក្តីស្លាប់ហើយចាប់ផ្តើមប្រាប់អ្នករាល់គ្នាជុំវិញព័ត៌មាននេះ។

ដោយផ្អែកលើពិធីការនេះ Cartridge រៀបចំការគ្រប់គ្រងការបរាជ័យដោយស្វ័យប្រវត្តិ។ ដំណើរការនីមួយៗតាមដានបរិយាកាសរបស់វា ហើយប្រសិនបើអ្នកដឹកនាំភ្លាមៗនោះឈប់ឆ្លើយតប នោះអ្នកចម្លងអាចកាន់កាប់តួនាទីរបស់វា ហើយ Cartridge កំណត់រចនាសម្ព័ន្ធតួនាទីដែលកំពុងដំណើរការទៅតាមនោះ។

អ្នកត្រូវប្រុងប្រយ័ត្ននៅទីនេះ ពីព្រោះការប្តូរទៅមកញឹកញាប់អាចនាំអោយមានជម្លោះទិន្នន័យកំឡុងពេលចម្លង។ ជាការពិតណាស់ការបើកការបរាជ័យដោយស្វ័យប្រវត្តិដោយចៃដន្យគឺមិនមានតម្លៃទេ។ អ្នកត្រូវយល់យ៉ាងច្បាស់អំពីអ្វីដែលកំពុងកើតឡើង ហើយត្រូវប្រាកដថាការចម្លងនឹងមិនខូចទេ បន្ទាប់ពីអ្នកដឹកនាំត្រូវបានស្ដារឡើងវិញ ហើយមកុដត្រូវបានប្រគល់ជូនគាត់វិញ។

ពីចំណុចទាំងអស់ខាងលើ អ្នកអាចមានអារម្មណ៍ថាតួនាទីគឺដូចជាសេវាមីក្រូ។ ក្នុងន័យមួយ ពួកគេគ្រាន់តែជាម៉ូឌុលនៅក្នុងដំណើរការ Tarantool ប៉ុណ្ណោះ។ ប៉ុន្តែក៏មានភាពខុសគ្នាជាមូលដ្ឋានមួយចំនួនផងដែរ។ ទីមួយ តួនាទីគម្រោងទាំងអស់ត្រូវតែរស់នៅក្នុងមូលដ្ឋានកូដដូចគ្នា។ ហើយដំណើរការ Tarantool ទាំងអស់ត្រូវតែដំណើរការពីមូលដ្ឋានកូដដូចគ្នា ដើម្បីកុំឱ្យមានការភ្ញាក់ផ្អើលដូចពេលដែលយើងព្យាយាមចាប់ផ្តើមកម្មវិធីកំណត់ពេលប៉ុន្តែវាមិនមានទេ។ ដូចគ្នានេះផងដែរ, អ្នកមិនគួរអនុញ្ញាតឱ្យមានភាពខុសគ្នានៅក្នុងកំណែកូដ, ដោយសារតែឥរិយាបថនៃប្រព័ន្ធក្នុងស្ថានភាពបែបនេះគឺពិបាកណាស់ក្នុងការទស្សន៍ទាយនិងបំបាត់កំហុស។

មិនដូច Docker ទេ យើងមិនអាចគ្រាន់តែយក "រូបភាព" នៃតួនាទីមួយ យកវាទៅម៉ាស៊ីនផ្សេងទៀត ហើយដំណើរការវានៅទីនោះនោះទេ។ តួនាទីរបស់យើងមិនដាច់ឆ្ងាយពី Docker containers ទេ។ ដូចគ្នានេះផងដែរ យើងមិនអាចដំណើរការតួនាទីដូចគ្នាពីរនៅលើឧទាហរណ៍តែមួយបានទេ។ តួនាទីមួយគឺនៅទីនោះ ឬវាមិនមាន ក្នុងន័យថាវាជា singleton។ ហើយទីបី នៅក្នុងក្រុមចម្លងទាំងមូល តួនាទីត្រូវតែដូចគ្នា ពីព្រោះបើមិនដូច្នេះទេ វានឹងគួរឱ្យអស់សំណើច - ទិន្នន័យគឺដូចគ្នា ប៉ុន្តែការកំណត់រចនាសម្ព័ន្ធគឺខុសគ្នា។

ឧបករណ៍ដាក់ពង្រាយ

ខ្ញុំបានសន្យាថានឹងបង្ហាញពីរបៀបដែល Cartridge ជួយដាក់ពង្រាយកម្មវិធី។ ដើម្បីធ្វើឱ្យជីវិតកាន់តែងាយស្រួលសម្រាប់អ្នកផ្សេងទៀត ក្របខ័ណ្ឌកញ្ចប់កញ្ចប់ RPM៖

$ cartridge pack rpm myapp -- упакует для нас ./myapp-0.1.0-1.rpm
$ sudo yum install ./myapp-0.1.0-1.rpm

កញ្ចប់ដែលបានដំឡើងមានស្ទើរតែគ្រប់អ្វីៗដែលអ្នកត្រូវការ៖ ទាំងកម្មវិធី និងភាពអាស្រ័យ lush ដែលបានដំឡើង។ Tarantool ក៏នឹងមកដល់ម៉ាស៊ីនមេផងដែរ សម្រាប់ការពឹងផ្អែកនៃកញ្ចប់ RPM ហើយសេវាកម្មរបស់យើងគឺរួចរាល់ដើម្បីដាក់ឱ្យដំណើរការ។ នេះត្រូវបានធ្វើតាមរយៈ systemd ប៉ុន្តែដំបូងអ្នកត្រូវសរសេរការកំណត់រចនាសម្ព័ន្ធបន្តិចបន្តួច។ យ៉ាងហោចណាស់ បញ្ជាក់ URI នៃដំណើរការនីមួយៗ។ បីគឺគ្រប់គ្រាន់សម្រាប់ឧទាហរណ៍មួយ។

$ sudo tee /etc/tarantool/conf.d/demo.yml <<CONFIG
myapp.router: {"advertise_uri": "localhost:3301", "http_port": 8080}
myapp.storage_A: {"advertise_uri": "localhost:3302", "http_enabled": False}
myapp.storage_B: {"advertise_uri": "localhost:3303", "http_enabled": False}
CONFIG

មាន nuance គួរឱ្យចាប់អារម្មណ៍នៅទីនេះ។ ជំនួសឱ្យការបញ្ជាក់គ្រាន់តែជាច្រកពិធីការប្រព័ន្ធគោលពីរ យើងបញ្ជាក់អាសយដ្ឋានសាធារណៈទាំងមូលនៃដំណើរការ រួមទាំងឈ្មោះម៉ាស៊ីនផងដែរ។ នេះគឺចាំបាច់ដើម្បីឱ្យថ្នាំងចង្កោមដឹងពីរបៀបភ្ជាប់ទៅគ្នាទៅវិញទៅមក។ វាជាគំនិតមិនល្អក្នុងការប្រើ 0.0.0.0 ជា advertise_uri វាគួរតែជា IP សាធារណៈ មិនមែន bind socket ទេ។ បើគ្មានវាទេ គ្មានអ្វីនឹងដំណើរការទេ ដូច្នេះ Cartridge នឹងមិនអនុញ្ញាតឱ្យអ្នកបើកថ្នាំងដែលមាន advertise_uri មិនត្រឹមត្រូវនោះទេ។

ឥឡូវនេះការកំណត់រចនាសម្ព័ន្ធរួចរាល់ អ្នកអាចចាប់ផ្តើមដំណើរការ។ ដោយសារឯកតាប្រព័ន្ធធម្មតាមិនអនុញ្ញាតឱ្យដំណើរការលើសពីមួយចាប់ផ្តើម កម្មវិធីនៅលើ Cartridge ត្រូវបានដំឡើងដោយអ្វីដែលគេហៅថា។ ឯកតាបន្ទាន់ដែលដំណើរការដូចនេះ៖

$ sudo systemctl start myapp@router
$ sudo systemctl start myapp@storage_A
$ sudo systemctl start myapp@storage_B

នៅក្នុងការកំណត់រចនាសម្ព័ន្ធ យើងបានបញ្ជាក់ច្រក HTTP ដែល Cartridge បម្រើចំណុចប្រទាក់បណ្ដាញ - 8080 ។ តោះទៅមើលវា៖

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

ចាក់កែវភេសជ្ជៈដែលអ្នកចូលចិត្ត ហើយសម្រាកបន្ទាប់ពីសប្តាហ៍ធ្វើការដ៏យូរ។ កម្មវិធីអាចដំណើរការបាន។