🥇ការអភិវឌ្ឍន៍កម្មវិធី និងការដាក់ឱ្យប្រើប្រាស់ពណ៌ខៀវបៃតង ដោយផ្អែកលើវិធីសាស្រ្តកម្មវិធីដប់ពីរកត្តាជាមួយនឹងឧទាហរណ៍នៅក្នុង php និង docker

ទីមួយទ្រឹស្តីតិចតួច។ តើមានរឿងអ្វីកើតឡើង កម្មវិធីដប់ពីរកត្តា?

នៅក្នុងពាក្យសាមញ្ញ ឯកសារនេះត្រូវបានរចនាឡើងដើម្បីសម្រួលដល់ការអភិវឌ្ឍន៍កម្មវិធី SaaS ជួយដោយការជូនដំណឹងដល់អ្នកអភិវឌ្ឍន៍ និងវិស្វករ DevOps អំពីបញ្ហា និងការអនុវត្តដែលជួបប្រទះញឹកញាប់បំផុតក្នុងការអភិវឌ្ឍន៍កម្មវិធីទំនើប។

ឯកសារនេះត្រូវបានបង្កើតឡើងដោយអ្នកអភិវឌ្ឍន៍នៃវេទិកា Heroku ។

កម្មវិធី Twelve-Factor App អាចត្រូវបានអនុវត្តចំពោះកម្មវិធីដែលសរសេរជាភាសាសរសេរកម្មវិធីណាមួយ និងប្រើប្រាស់ការរួមបញ្ចូលគ្នានៃសេវាកម្មគាំទ្រ (មូលដ្ឋានទិន្នន័យ ជួរសារ ឃ្លាំងសម្ងាត់។ល។)។

ដោយសង្ខេបអំពីកត្តាដែលវិធីសាស្ត្រនេះផ្អែកលើ៖

មូលដ្ឋានកូដ - មូលដ្ឋានកូដមួយត្រូវបានតាមដាននៅក្នុងការគ្រប់គ្រងកំណែ - ការដាក់ពង្រាយច្រើន។
ភាពអាស្រ័យ - ប្រកាសច្បាស់លាស់ និងញែកភាពអាស្រ័យ
ការកំណត់រចនាសម្ព័ន្ធ - រក្សាទុកការកំណត់នៅក្នុងពេលដំណើរការ
សេវាកម្មគាំទ្រ - ពិចារណាសេវាកម្មគាំទ្រជាធនធានកម្មវិធីជំនួយ
កសាង, ដោះលែង, រត់ - បំបែកដំណាក់កាលដំឡើង និងប្រតិបត្តិយ៉ាងតឹងរ៉ឹង
ដំណើរការ - ដំណើរការកម្មវិធីជាដំណើរការគ្មានរដ្ឋមួយ ឬច្រើន។
ការភ្ជាប់ច្រក - សេវាកម្មនាំចេញតាមរយៈការចងច្រក
ភាពស្របគ្នា - ធ្វើមាត្រដ្ឋានកម្មវិធីរបស់អ្នកដោយប្រើដំណើរការ
ពិការភាព - បង្កើនភាពជឿជាក់ជាអតិបរមាជាមួយនឹងការចាប់ផ្តើមរហ័ស និងការបិទស្អាត
ការអភិវឌ្ឍន៍កម្មវិធី/ភាពស្មើគ្នានៃប្រតិបត្តិការ - រក្សាការអភិវឌ្ឍន៍ ដំណាក់កាល និងបរិយាកាសផលិតកម្មរបស់អ្នកឱ្យស្រដៀងគ្នាតាមដែលអាចធ្វើទៅបាន។
ការកាប់ឈើ - មើលកំណត់ហេតុជាស្ទ្រីមនៃព្រឹត្តិការណ៍
កិច្ចការរដ្ឋបាល - អនុវត្តការងាររដ្ឋបាល/គ្រប់គ្រងដោយប្រើដំណើរការពិសេស

អ្នកអាចទទួលបានព័ត៌មានបន្ថែមអំពីកត្តាទាំង 12 ពីប្រភពខាងក្រោម៖

ប្រភពផ្លូវការ - ត្រូវតែអាន
អត្ថបទអំពី habr ។ កម្មវិធីដប់ពីរកត្តា - ការបកប្រែជាផ្លូវការ
អត្ថបទអំពី habr ។ កត្តាបាត់ខ្លួន 7 នៅក្នុងកម្មវិធី 12 Factor - ពិនិត្យមើលឡើងវិញនូវកត្តាទាំង 12 ដោយមានគោលបំណងកែលម្អពួកគេ។

តើការដាក់ពង្រាយពណ៌ខៀវបៃតងគឺជាអ្វី?

ការដាក់ពង្រាយខៀវបៃតងគឺជាវិធីសាស្រ្តនៃការផ្តល់ជូននូវកម្មវិធីមួយទៅ ផលិតកម្ម តាមរបៀបដែលអតិថិជនចុងក្រោយមិនឃើញការផ្លាស់ប្តូរណាមួយនៅលើផ្នែករបស់គាត់។ ម្យ៉ាងវិញទៀត ការដាក់ពង្រាយកម្មវិធីជាមួយសូន្យ ពេលវេលារងចាំ.

គ្រោងការណ៍ដាក់ពង្រាយ BG បុរាណមើលទៅដូចដែលបានបង្ហាញក្នុងរូបភាពខាងក្រោម។

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

វាទាំងអស់មើលទៅល្អណាស់ ហើយនៅ glance ដំបូងមិនគួរមានបញ្ហាអ្វីជាមួយវាទេ។
ប៉ុន្តែចាប់តាំងពីយើងរស់នៅក្នុងពិភពទំនើបជម្រើសជាមួយនឹងការប្តូររូបរាងកាយដូចដែលបានចង្អុលបង្ហាញនៅក្នុងគ្រោងការណ៍បុរាណមិនសមនឹងយើងទេ។ កត់ត្រាព័ត៌មានសម្រាប់ពេលនេះ យើងនឹងត្រលប់ទៅវានៅពេលក្រោយ។

ដំបូន្មានល្អនិងអាក្រក់

ការមិនទទួលខុសត្រូវ៖ ឧទាហរណ៍ខាងក្រោមបង្ហាញពីឧបករណ៍ប្រើប្រាស់/វិធីសាស្រ្តដែលខ្ញុំប្រើ អ្នកអាចប្រើជម្រើសណាមួយដែលមានមុខងារស្រដៀងគ្នា។

ឧទាហរណ៍ភាគច្រើននឹងប្រសព្វគ្នាជាមួយការអភិវឌ្ឍន៍គេហទំព័រ (នេះគឺជាការភ្ញាក់ផ្អើលមួយ) ជាមួយ PHP និង Docker ។

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

1. មូលដ្ឋានកូដ

ប្រើ FTP និង FileZilla ដើម្បីបង្ហោះឯកសារទៅម៉ាស៊ីនមេម្តងមួយៗ កុំរក្សាទុកកូដនៅកន្លែងណាក្រៅពីនៅលើម៉ាស៊ីនមេផលិតកម្ម។

គម្រោងនេះគួរតែមានមូលដ្ឋានកូដតែមួយ ពោលគឺកូដទាំងអស់បានមកពីលេខមួយ។ Git ឃ្លាំង។ ម៉ាស៊ីនមេ (ការផលិត, ដំណាក់កាល, test1, test2...) ប្រើកូដពីសាខានៃឃ្លាំងទូទៅមួយ។ វិធីនេះយើងសម្រេចបាននូវភាពស៊ីសង្វាក់គ្នានៃកូដ។

2. ភាពអាស្រ័យ

ទាញយកបណ្ណាល័យទាំងអស់នៅក្នុងថតដោយផ្ទាល់ទៅឫសនៃគម្រោង។ ធ្វើបច្ចុប្បន្នភាពដោយសាមញ្ញដោយផ្ទេរលេខកូដថ្មីទៅថតជាមួយកំណែបច្ចុប្បន្ននៃបណ្ណាល័យ។ ដំឡើងឧបករណ៍ប្រើប្រាស់ចាំបាច់ទាំងអស់ដោយផ្ទាល់នៅលើម៉ាស៊ីនមេដែលមានសេវាកម្ម 20 បន្ថែមទៀតកំពុងដំណើរការ។

គម្រោងមួយគួរតែមានបញ្ជីភាពអាស្រ័យដែលអាចយល់បានយ៉ាងច្បាស់ (ដោយភាពអាស្រ័យ ខ្ញុំក៏មានន័យថាបរិស្ថានដែរ)។ ភាពអាស្រ័យទាំងអស់ត្រូវតែត្រូវបានកំណត់យ៉ាងច្បាស់លាស់ និងដាច់ដោយឡែក។
ចូរយើងយកជាឧទាហរណ៍ កម្មវិធីតែង и Dockers.

កម្មវិធីតែង - កម្មវិធីគ្រប់គ្រងកញ្ចប់ដែលអនុញ្ញាតឱ្យអ្នកដំឡើងបណ្ណាល័យនៅក្នុង PHP ។ កម្មវិធីតែងអនុញ្ញាតឱ្យអ្នកបញ្ជាក់កំណែយ៉ាងតឹងរ៉ឹង ឬរលុង ហើយកំណត់ពួកវាយ៉ាងច្បាស់។ វាអាចមាន 20 គម្រោងផ្សេងគ្នានៅលើម៉ាស៊ីនមេ ហើយនីមួយៗនឹងមានបញ្ជីកញ្ចប់ និងបណ្ណាល័យផ្ទាល់ខ្លួនដោយឯករាជ្យ។

Dockers - ឧបករណ៍ប្រើប្រាស់ដែលអនុញ្ញាតឱ្យអ្នកកំណត់ និងញែកបរិយាកាសដែលកម្មវិធីនឹងដំណើរការ។ ដូច្នោះហើយ ដូចគ្នានឹងកម្មវិធីតែងដែរ ប៉ុន្តែហ្មត់ចត់ជាងនេះទៅទៀត យើងអាចកំណត់ថាតើកម្មវិធីដំណើរការជាមួយអ្វី។ ជ្រើសរើសកំណែជាក់លាក់របស់ PHP ដំឡើងតែកញ្ចប់ដែលចាំបាច់សម្រាប់គម្រោងដំណើរការ ដោយមិនចាំបាច់បន្ថែមអ្វីបន្ថែម។ ហើយសំខាន់បំផុតដោយមិនជ្រៀតជ្រែកជាមួយកញ្ចប់ និងបរិស្ថាននៃម៉ាស៊ីនម៉ាស៊ីន និងគម្រោងផ្សេងៗទៀត។ នោះគឺគម្រោងទាំងអស់នៅលើម៉ាស៊ីនមេដែលដំណើរការតាមរយៈ Docker អាចប្រើប្រាស់កញ្ចប់ណាមួយ និងបរិយាកាសខុសគ្នាទាំងស្រុង។

3. ការកំណត់រចនាសម្ព័ន្ធ

រក្សាទុកការកំណត់ជាថេរដោយផ្ទាល់នៅក្នុងកូដ។ ញែកថេរសម្រាប់ម៉ាស៊ីនមេសាកល្បង ដាច់ដោយឡែកសម្រាប់ផលិត។ ភ្ជាប់ប្រតិបត្តិការនៃកម្មវិធីអាស្រ័យលើបរិស្ថានដោយផ្ទាល់នៅក្នុងតក្កវិជ្ជាអាជីវកម្មនៃគម្រោងដោយប្រើប្រសិនបើផ្សេងទៀតសាងសង់។

ការកំណត់រចនាសម្ព័ន្ធ - នេះគឺជាវិធីតែមួយគត់ដែលការដាក់ពង្រាយគម្រោងគួរតែខុសគ្នា។ តាមឧត្ដមគតិ ការកំណត់រចនាសម្ព័ន្ធគួរតែត្រូវបានឆ្លងកាត់អថេរបរិស្ថាន (env vars)។

នោះគឺទោះបីជាអ្នករក្សាទុកឯកសារកំណត់រចនាសម្ព័ន្ធជាច្រើន .config.prod .config.local ហើយប្តូរឈ្មោះពួកវានៅពេលដាក់ឱ្យប្រើប្រាស់ទៅ .config (ការកំណត់សំខាន់ដែលកម្មវិធីអានទិន្នន័យ) - នេះនឹងមិនមែនជាវិធីសាស្រ្តត្រឹមត្រូវទេ ចាប់តាំងពី ក្នុងករណីនេះ ព័ត៌មានពីការកំណត់រចនាសម្ព័ន្ធនឹងមានជាសាធារណៈសម្រាប់អ្នកអភិវឌ្ឍន៍កម្មវិធីទាំងអស់ ហើយទិន្នន័យពីម៉ាស៊ីនមេផលិតកម្មនឹងត្រូវបានសម្របសម្រួល។ ការកំណត់រចនាសម្ព័ន្ធទាំងអស់ត្រូវតែរក្សាទុកដោយផ្ទាល់នៅក្នុងប្រព័ន្ធដាក់ពង្រាយ (CI/CD) និងបង្កើតសម្រាប់បរិស្ថានផ្សេងៗគ្នាជាមួយនឹងតម្លៃខុសៗគ្នាដែលចាំបាច់សម្រាប់បរិស្ថានជាក់លាក់មួយនៅពេលដាក់ឱ្យប្រើប្រាស់។

4. សេវាភាគីទីបី

ត្រូវភ្ជាប់យ៉ាងតឹងរ៉ឹងទៅនឹងបរិស្ថាន ប្រើប្រាស់ការតភ្ជាប់ផ្សេងគ្នាសម្រាប់សេវាកម្មដូចគ្នានៅក្នុងបរិយាកាសជាក់លាក់។

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

ការតភ្ជាប់ទាំងអស់ទៅកាន់សេវាកម្មខាងក្រៅ ដូចជាម៉ាស៊ីនមេជួរ មូលដ្ឋានទិន្នន័យ សេវាកម្មឃ្លាំងសម្ងាត់ ត្រូវតែដូចគ្នាសម្រាប់ទាំងបរិស្ថានមូលដ្ឋាន និងបរិស្ថានភាគីទីបី/ផលិតកម្ម។ ម្យ៉ាងវិញទៀត នៅពេលណាមួយ តាមរយៈការផ្លាស់ប្តូរខ្សែតភ្ជាប់ ខ្ញុំអាចជំនួសការហៅទៅមូលដ្ឋានលេខ 1 ជាមួយនឹងមូលដ្ឋានលេខ 2 ដោយមិនចាំបាច់ផ្លាស់ប្តូរលេខកូដកម្មវិធី។ ឬមើលទៅខាងមុខ ជាឧទាហរណ៍ នៅពេលធ្វើមាត្រដ្ឋានសេវាកម្ម អ្នកនឹងមិនចាំបាច់បញ្ជាក់ការតភ្ជាប់តាមវិធីពិសេសណាមួយសម្រាប់ម៉ាស៊ីនមេឃ្លាំងសម្ងាត់បន្ថែមទេ។

5. កសាង, ដោះលែង, ប្រតិបត្តិ

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

គ្រប់ដំណាក់កាលនៃការដាក់ពង្រាយត្រូវតែបំបែកចេញពីគ្នាទៅវិញទៅមក។

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

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

6. ដំណើរការ

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

ទាក់ទងនឹងវគ្គ រក្សាទុកទិន្នន័យតែក្នុងឃ្លាំងសម្ងាត់ដែលគ្រប់គ្រងដោយសេវាកម្មភាគីទីបី (memcached, redis) ដូច្នេះទោះបីជាអ្នកមានដំណើរការកម្មវិធីចំនួន 20 កំពុងដំណើរការក៏ដោយ ក្នុងចំណោមពួកគេដែលបានចូលប្រើឃ្លាំងសម្ងាត់នឹងអាចបន្តធ្វើការជាមួយអតិថិជននៅក្នុង ស្ថានភាពដូចគ្នាដែលអ្នកប្រើប្រាស់កំពុងធ្វើការជាមួយកម្មវិធីក្នុងដំណើរការផ្សេងទៀត។ ជាមួយនឹងវិធីសាស្រ្តនេះ វាប្រែថាមិនថាអ្នកប្រើសេវាកម្មភាគីទីបីចំនួនប៉ុន្មានទេ អ្វីគ្រប់យ៉ាងនឹងដំណើរការជាធម្មតា និងមិនមានបញ្ហាជាមួយនឹងការចូលប្រើទិន្នន័យ។

7. ការចងច្រក

មានតែម៉ាស៊ីនមេគេហទំព័រប៉ុណ្ណោះដែលដឹងពីរបៀបធ្វើការជាមួយសេវាកម្មភាគីទីបី។ ឬប្រសើរជាងនេះ ដំឡើងសេវាកម្មភាគីទីបីដោយផ្ទាល់នៅខាងក្នុងម៉ាស៊ីនមេគេហទំព័រ។ ឧទាហរណ៍ដូចជាម៉ូឌុល PHP នៅក្នុង Apache ។
សេវាកម្មទាំងអស់របស់អ្នកត្រូវតែអាចចូលប្រើបានគ្នាទៅវិញទៅមកតាមរយៈការចូលទៅកាន់អាសយដ្ឋាន និងច្រកមួយចំនួន (localgost:5432, localhost:3000, nginx:80, php-fpm:9000) នោះគឺពី nginx ខ្ញុំអាចចូលប្រើបានទាំង php-fpm និងទៅកាន់ postgres និងពី php-fpm ទៅ postgres និង nginx ហើយតាមពិតពីសេវានីមួយៗ ខ្ញុំអាចចូលប្រើសេវាកម្មផ្សេងទៀត។ តាមវិធីនេះ លទ្ធភាពជោគជ័យនៃសេវាកម្មមួយមិនត្រូវបានចងភ្ជាប់ទៅនឹងលទ្ធភាពជោគជ័យនៃសេវាកម្មមួយផ្សេងទៀតទេ។

8. ភាពស្របគ្នា។

ធ្វើការជាមួយដំណើរការមួយ បើមិនដូច្នេះទេ ដំណើរការជាច្រើននឹងមិនអាចទាក់ទងគ្នាបានទេ!

ទុកកន្លែងសម្រាប់ធ្វើមាត្រដ្ឋាន។ Docker swarm គឺល្អសម្រាប់រឿងនេះ។
Docker Swarm គឺជាឧបករណ៍សម្រាប់បង្កើត និងគ្រប់គ្រងចង្កោមកុងតឺន័រ ទាំងរវាងម៉ាស៊ីនផ្សេងគ្នា និងធុងជាច្រើននៅលើម៉ាស៊ីនតែមួយ។

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

9. ពិការភាព

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

ដំណើរការ និងសេវាកម្មនីមួយៗអាចត្រូវបានបិទនៅពេលណាក៏បាន ហើយនេះមិនគួរប៉ះពាល់ដល់សេវាកម្មផ្សេងទៀតទេ (ជាការពិតណាស់ នេះមិនមានន័យថាសេវាកម្មនេះនឹងមិនអាចប្រើបានសម្រាប់សេវាកម្មផ្សេងទៀតនោះទេ ប៉ុន្តែសេវាកម្មផ្សេងទៀតនឹងមិនបិទបន្ទាប់ពីសេវាកម្មនេះ)។ ដំណើរការទាំងអស់ត្រូវតែត្រូវបានបញ្ចប់ដោយរលូន ដូច្នេះនៅពេលដែលពួកវាត្រូវបានបញ្ចប់ នោះគ្មានទិន្នន័យណាមួយត្រូវបានខូចខាតទេ ហើយប្រព័ន្ធនឹងដំណើរការបានត្រឹមត្រូវនៅពេលដែលអ្នកបើកវាលើកក្រោយ។ នោះគឺ ទោះបីជាក្នុងករណីមានការបញ្ចប់ជាបន្ទាន់ក៏ដោយ ទិន្នន័យមិនគួរត្រូវបានខូចខាតទេ (យន្តការប្រតិបត្តិការគឺសមរម្យនៅទីនេះ សំណួរក្នុងមូលដ្ឋានទិន្នន័យដំណើរការតែជាក្រុមប៉ុណ្ណោះ ហើយប្រសិនបើយ៉ាងហោចណាស់សំណួរមួយពីក្រុមបរាជ័យ ឬត្រូវបានប្រតិបត្តិជាមួយ error, បន្ទាប់មកមិនមានសំណួរផ្សេងទៀតពីក្រុមចុងក្រោយបរាជ័យនៅក្នុងការពិត).

10. ការអភិវឌ្ឍន៍កម្មវិធី/ភាពស្មើគ្នានៃប្រតិបត្តិការ

ការផលិត ដំណាក់កាល និងកំណែមូលដ្ឋាននៃកម្មវិធីត្រូវតែខុសគ្នា។ នៅក្នុងការផលិត យើងប្រើក្របខ័ណ្ឌ Yii Lite និងក្នុងស្រុក Yii ដើម្បីឱ្យវាដំណើរការលឿនក្នុងផលិតកម្ម!

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

Docker ក៏ជួយយើងក្នុងរឿងនេះដែរ។ ប្រសិនបើចំណុចមុនទាំងអស់ត្រូវបានគេសង្កេតឃើញ ការប្រើ docker នឹងនាំមកនូវដំណើរការនៃការដាក់ពង្រាយបរិស្ថានទាំងលើការផលិត និងនៅលើម៉ាស៊ីនមូលដ្ឋានដើម្បីបញ្ចូលពាក្យបញ្ជាមួយ ឬពីរ។

11. កំណត់ហេតុ

យើងសរសេរកំណត់ហេតុទៅឯកសារ និងមូលដ្ឋានទិន្នន័យ! យើងមិនសម្អាតឯកសារ និងមូលដ្ឋានទិន្នន័យពីកំណត់ហេតុទេ។ តោះទិញ hard drive ដែលមាន 9000 Peta bytes ហើយវាល្អណាស់។

កំណត់ហេតុទាំងអស់គួរតែត្រូវបានចាត់ទុកថាជាស្ទ្រីមនៃព្រឹត្តិការណ៍មួយ។ កម្មវិធីខ្លួនវាមិនគួរពាក់ព័ន្ធនឹងការដំណើរការកំណត់ហេតុទេ។ កំណត់ហេតុគួរតែចេញជា stdout ឬផ្ញើតាមរយៈពិធីការដូចជា udp ដូច្នេះការធ្វើការជាមួយកំណត់ហេតុមិនបង្កើតបញ្ហាណាមួយសម្រាប់កម្មវិធីនោះទេ។ greylog គឺល្អសម្រាប់រឿងនេះ។ Graylog ទទួលកំណត់ហេតុទាំងអស់តាមរយៈ udp (ពិធីការនេះមិនតម្រូវឱ្យរង់ចាំការឆ្លើយតបអំពីការទទួលកញ្ចប់ព័ត៌មានដោយជោគជ័យ) មិនជ្រៀតជ្រែកជាមួយកម្មវិធីតាមមធ្យោបាយណាមួយឡើយ ហើយគ្រាន់តែដោះស្រាយជាមួយនឹងរចនាសម្ព័ន្ធ និងដំណើរការកំណត់ហេតុប៉ុណ្ណោះ។ តក្កវិជ្ជាកម្មវិធីមិនផ្លាស់ប្តូរដើម្បីធ្វើការជាមួយវិធីសាស្រ្តបែបនេះទេ។

12. កិច្ចការរដ្ឋបាល

ដើម្បីធ្វើបច្ចុប្បន្នភាពទិន្នន័យ មូលដ្ឋានទិន្នន័យ។ល។ ប្រើចំណុចបញ្ចប់ដែលបានបង្កើតដាច់ដោយឡែកនៅក្នុង API ដោយប្រតិបត្តិវា 2 ដងជាប់គ្នានឹងនាំឱ្យអ្វីៗទាំងអស់ស្ទួន។ ប៉ុន្តែអ្នកមិនល្ងង់ទេ អ្នកនឹងមិនចុចពីរដងទេ ហើយយើងមិនត្រូវការការធ្វើចំណាកស្រុកទេ។

កិច្ចការរដ្ឋបាលទាំងអស់គួរតែត្រូវបានអនុវត្តក្នុងបរិយាកាសដូចគ្នាជាមួយនឹងកូដទាំងអស់នៅកម្រិតចេញផ្សាយ។ នោះគឺប្រសិនបើយើងត្រូវការផ្លាស់ប្តូររចនាសម្ព័ន្ធនៃមូលដ្ឋានទិន្នន័យ នោះយើងនឹងមិនធ្វើវាដោយដៃដោយការផ្លាស់ប្តូរឈ្មោះជួរឈរ និងបន្ថែមធាតុថ្មីតាមរយៈឧបករណ៍គ្រប់គ្រងមូលដ្ឋានទិន្នន័យដែលមើលឃើញមួយចំនួន។ សម្រាប់រឿងបែបនេះ យើងបង្កើតស្គ្រីបដាច់ដោយឡែក - ការធ្វើចំណាកស្រុក ដែលត្រូវបានប្រតិបត្តិគ្រប់ទីកន្លែង និងគ្រប់មជ្ឈដ្ឋានតាមរបៀបដូចគ្នាជាមួយនឹងលទ្ធផលទូទៅ និងអាចយល់បាន។ សម្រាប់កិច្ចការផ្សេងទៀតទាំងអស់ ដូចជាការបំពេញគម្រោងជាមួយនឹងទិន្នន័យ វិធីសាស្ត្រស្រដៀងគ្នាគួរតែត្រូវបានប្រើ។

ការអនុវត្តឧទាហរណ៍នៅក្នុង PHP, Laravel, Laradock, Docker-Compose

PS ឧទាហរណ៍ទាំងអស់ត្រូវបានធ្វើឡើងនៅលើ MacOS ។ ពួកគេភាគច្រើនក៏សមរម្យសម្រាប់លីនុចផងដែរ។ អ្នកប្រើ Windows អត់ទោសឱ្យខ្ញុំ ប៉ុន្តែខ្ញុំមិនបានធ្វើការជាមួយ Windows យូរមកហើយ។

ចូរស្រមៃមើលស្ថានភាពដែលយើងមិនមានកំណែ PHP ណាមួយដែលបានដំឡើងនៅលើកុំព្យូទ័ររបស់យើង ហើយគ្មានអ្វីទាំងអស់។
ដំឡើងកំណែចុងក្រោយបំផុតនៃ docker និង docker-compose ។ (នេះអាចរកបាននៅលើអ៊ីនធឺណិត)

docker -v && 
docker-compose -v

1. ដាក់ ឡារ៉ាដក់

git clone https://github.com/Laradock/laradock.git && 
ls

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

2. កំណត់រចនាសម្ព័ន្ធ Laradock ដើម្បីដំណើរការកម្មវិធីរបស់យើង។

cd laradock && 
cp env-example .env

២.១. បើកថត habr (ថតមេដែល laradock ត្រូវបានក្លូន) នៅក្នុងកម្មវិធីនិពន្ធមួយចំនួន។ (ក្នុងករណី PHPStorm របស់ខ្ញុំ)

នៅដំណាក់កាលនេះ យើងគ្រាន់តែដាក់ឈ្មោះគម្រោងប៉ុណ្ណោះ។

២.២. បើកដំណើរការរូបភាពកន្លែងធ្វើការ។ (ក្នុងករណីរបស់អ្នក រូបភាពនឹងចំណាយពេលខ្លះក្នុងការសាងសង់)
កន្លែងធ្វើការគឺជារូបភាពដែលបានរៀបចំជាពិសេសសម្រាប់ធ្វើការជាមួយក្របខ័ណ្ឌក្នុងនាមអ្នកអភិវឌ្ឍន៍។

យើងចូលទៅក្នុងធុងដោយប្រើ

docker-compose up -d workspace && 
docker-compose exec workspace bash

២.៣. ការដំឡើង Laravel

composer create-project --prefer-dist laravel/laravel application

២.៤. បន្ទាប់ពីដំឡើងរួច យើងពិនិត្យមើលថាតើថតដែលមានគម្រោងត្រូវបានបង្កើតឡើងហើយឬអត់។

ls
exit
docker-compose down

២.៥. ចូរយើងត្រលប់ទៅ PHPStorm ហើយកំណត់ផ្លូវត្រឹមត្រូវទៅកាន់កម្មវិធី laravel របស់យើងនៅក្នុងឯកសារ .env ។

3. បន្ថែមកូដទាំងអស់ទៅ Git ។

ដើម្បីធ្វើដូចនេះយើងនឹងបង្កើតឃ្លាំងនៅលើ Github (ឬកន្លែងផ្សេងទៀត) ។ តោះទៅថត habr នៅក្នុង terminal ហើយប្រតិបត្តិកូដខាងក្រោម។

echo "# habr-12factor" >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin [email protected]:nzulfigarov/habr-12factor.git # здесь будет ссылка на ваш репо
git push -u origin master
git status

ចូរយើងពិនិត្យមើលថាតើអ្វីៗគ្រប់យ៉ាងស្ថិតក្នុងលំដាប់ឬអត់

ដើម្បីភាពងាយស្រួល ខ្ញុំសូមណែនាំឱ្យប្រើចំណុចប្រទាក់ដែលមើលឃើញមួយចំនួនសម្រាប់ Git ក្នុងករណីរបស់ខ្ញុំ GitKraken. (នេះគឺជាតំណយោង)

4. តោះចាប់ផ្តើម!

មុនពេលចាប់ផ្តើម ត្រូវប្រាកដថាគ្មានអ្វីព្យួរនៅលើច្រក 80 និង 443 ទេ។

docker-compose up -d nginx php-fpm

ដូច្នេះហើយ គម្រោងរបស់យើងមានសេវាកម្ម 3 ដាច់ដោយឡែកពីគ្នា៖

nginx - ម៉ាស៊ីនមេគេហទំព័រ
php-fpm - php សម្រាប់ទទួលសំណើពីម៉ាស៊ីនមេគេហទំព័រ
កន្លែងធ្វើការ - php សម្រាប់អ្នកអភិវឌ្ឍន៍

នៅពេលនេះ យើងសម្រេចបានថា យើងបានបង្កើតកម្មវិធីមួយដែលត្រូវនឹង 4 ចំណុចក្នុងចំណោម 12 គឺ:

1. មូលដ្ឋានកូដ - កូដទាំងអស់ស្ថិតនៅក្នុងឃ្លាំងមួយ (ចំណាំតូច៖ វាអាចត្រឹមត្រូវក្នុងការបន្ថែម docker នៅខាងក្នុងគម្រោង laravel ប៉ុន្តែវាមិនសំខាន់ទេ)។

2. ភាពអាស្រ័យ - ភាពអាស្រ័យទាំងអស់របស់យើងត្រូវបានសរសេរយ៉ាងច្បាស់លាស់នៅក្នុង application/composer.json និងក្នុង Dockerfile នីមួយៗនៃកុងតឺន័រនីមួយៗ។

3. សេវាកម្មគាំទ្រ - សេវាកម្មនីមួយៗ (php-fom, nignx, workspace) រស់នៅក្នុងជីវិតរបស់ខ្លួន ហើយត្រូវបានភ្ជាប់ពីខាងក្រៅ ហើយនៅពេលធ្វើការជាមួយសេវាកម្មមួយ សេវាកម្មផ្សេងទៀតនឹងមិនរងផលប៉ះពាល់ទេ។

4. ដំណើរការ - សេវាកម្មនីមួយៗគឺជាដំណើរការមួយ។ សេវាកម្មនីមួយៗមិនរក្សាស្ថានភាពផ្ទៃក្នុងទេ។

5. ការភ្ជាប់ច្រក

docker ps

ដូចដែលយើងអាចមើលឃើញ សេវាកម្មនីមួយៗដំណើរការនៅលើច្រករបស់វា ហើយអាចចូលប្រើបានចំពោះសេវាកម្មផ្សេងទៀតទាំងអស់។

6. ភាពស្របគ្នា

Docker អនុញ្ញាតឱ្យយើងបង្កើតដំណើរការជាច្រើននៃសេវាកម្មដូចគ្នាជាមួយនឹងតុល្យភាពការផ្ទុកដោយស្វ័យប្រវត្តិរវាងពួកវា។

ចូរយើងបញ្ឈប់កុងតឺន័រ ហើយរត់វាតាមទង់ជាតិ --ខ្នាត

docker-compose down && 
docker-compose up -d --scale php-fpm=3 nginx php-fpm

ដូចដែលយើងអាចមើលឃើញ ច្បាប់ចម្លងត្រូវបានបង្កើត php-fpm container ។ យើងមិនចាំបាច់ផ្លាស់ប្តូរអ្វីទាំងអស់ក្នុងការធ្វើការជាមួយធុងនេះទេ។ យើងក៏បន្តចូលប្រើវានៅលើច្រក 9000 ហើយ Docker គ្រប់គ្រងការផ្ទុករវាងកុងតឺន័រសម្រាប់យើង។

7. ពិការភាព - កុងតឺន័រនីមួយៗអាចសម្លាប់ដោយមិនបង្កគ្រោះថ្នាក់ដល់អ្នកដទៃ។ ការបញ្ឈប់ ឬចាប់ផ្តើមកុងតឺន័រឡើងវិញនឹងមិនប៉ះពាល់ដល់ប្រតិបត្តិការនៃកម្មវិធីកំឡុងពេលបើកដំណើរការជាបន្តបន្ទាប់នោះទេ។ ធុងនីមួយៗក៏អាចលើកបានគ្រប់ពេលផងដែរ។

8. ការអភិវឌ្ឍន៍កម្មវិធី/ភាពស្មើគ្នានៃប្រតិបត្តិការ - បរិស្ថានរបស់យើងទាំងអស់គឺដូចគ្នា។ ដោយដំណើរការប្រព័ន្ធនៅលើម៉ាស៊ីនមេនៅក្នុងផលិតកម្ម អ្នកនឹងមិនចាំបាច់ផ្លាស់ប្តូរអ្វីនៅក្នុងពាក្យបញ្ជារបស់អ្នកទេ។ អ្វីគ្រប់យ៉ាងនឹងផ្អែកលើ Docker តាមរបៀបដូចគ្នា។

9. ការកាប់ឈើ — កំណត់ហេតុទាំងអស់នៅក្នុងកុងតឺន័រទាំងនេះចូលទៅកាន់ការផ្សាយ ហើយអាចមើលឃើញនៅក្នុងកុងសូល Docker ។ (ក្នុងករណីនេះ តាមពិតជាមួយធុងផលិតនៅផ្ទះផ្សេងទៀត នេះប្រហែលជាមិនមែនជាករណីទេប្រសិនបើអ្នកមិនបានថែរក្សាវា)

 docker-compose logs -f

ប៉ុន្តែមានការចាប់បានថាតម្លៃលំនាំដើមនៅក្នុង PHP និង Nginx ក៏សរសេរកំណត់ហេតុទៅឯកសារមួយ។ ដើម្បីបំពេញកត្តាទាំង ១២ គឺចាំបាច់ ផ្តាច់ សរសេរកំណត់ហេតុទៅឯកសារក្នុងការកំណត់រចនាសម្ព័ន្ធនៃកុងតឺន័រនីមួយៗដាច់ដោយឡែក។

Docker ក៏ផ្តល់នូវសមត្ថភាពក្នុងការផ្ញើកំណត់ហេតុមិនត្រឹមតែដើម្បី stdout ប៉ុណ្ណោះទេប៉ុន្តែថែមទាំងសម្រាប់រឿងដូចជា graylog ដែលខ្ញុំបានរៀបរាប់ខាងលើ។ ហើយនៅខាងក្នុង greylog យើងអាចដំណើរការកំណត់ហេតុតាមដែលយើងពេញចិត្ត ហើយកម្មវិធីរបស់យើងនឹងមិនកត់សំគាល់វាតាមមធ្យោបាយណាមួយឡើយ។

10. កិច្ចការរដ្ឋបាល - រាល់កិច្ចការរដ្ឋបាលទាំងអស់ត្រូវបានដោះស្រាយដោយ laravel អរគុណចំពោះឧបករណ៍សិប្បករយ៉ាងពិតប្រាកដ ដូចដែលអ្នកបង្កើតកម្មវិធីកត្តា 12 ចង់បាន។

ជាឧទាហរណ៍ ខ្ញុំនឹងបង្ហាញពីរបៀបដែលពាក្យបញ្ជាមួយចំនួនត្រូវបានប្រតិបត្តិ។
យើងចូលទៅក្នុងធុង។

 
docker-compose exec workspace bash
php artisan list

ឥឡូវនេះយើងអាចប្រើពាក្យបញ្ជាណាមួយ។ (សូមចំណាំថាយើងមិនបានកំណត់រចនាសម្ព័ន្ធមូលដ្ឋានទិន្នន័យ និងឃ្លាំងសម្ងាត់ទេ ដូច្នេះពាក់កណ្តាលនៃពាក្យបញ្ជានឹងមិនត្រូវបានប្រតិបត្តិត្រឹមត្រូវទេ ព្រោះវាត្រូវបានរចនាឡើងដើម្បីធ្វើការជាមួយឃ្លាំងសម្ងាត់ និងមូលដ្ឋានទិន្នន័យ)។

11. ការកំណត់រចនាសម្ព័ន្ធ និង ១៥០០ ។ កសាង, ដោះលែង, រត់

ខ្ញុំចង់ឧទ្ទិសផ្នែកនេះទៅ Blue-Green Deployment ប៉ុន្តែវាប្រែទៅជាទូលំទូលាយពេកសម្រាប់អត្ថបទនេះ។ ខ្ញុំនឹងសរសេរអត្ថបទដាច់ដោយឡែកអំពីរឿងនេះ។

សរុបមក គំនិតគឺផ្អែកលើប្រព័ន្ធ CI/CD ដូចជា Jenkins и Gitlab CI. នៅក្នុងទាំងពីរ អ្នកអាចកំណត់អថេរបរិស្ថានដែលទាក់ទងនឹងបរិស្ថានជាក់លាក់មួយ។ ដូច្នោះហើយក្នុងស្ថានភាពនេះចំណុច c នឹងត្រូវបានបំពេញ ការកំណត់រចនាសម្ព័ន្ធ.

និងចំណុចអំពី កសាង, ដោះលែង, រត់ ត្រូវបានដោះស្រាយដោយមុខងារដែលភ្ជាប់មកជាមួយឈ្មោះ បំពង់បង្ហូរ.

បំពង់បង្ហូរ អនុញ្ញាតឱ្យអ្នកបែងចែកដំណើរការដាក់ពង្រាយជាដំណាក់កាលជាច្រើន ដោយគូសបញ្ជាក់ពីដំណាក់កាលនៃការជួបប្រជុំ ការចេញផ្សាយ និងការប្រតិបត្តិ។ ផងដែរនៅក្នុង Pipeline អ្នកអាចបង្កើតការបម្រុងទុក និងពិតជាអ្វីទាំងអស់។ នេះគឺជាឧបករណ៍ដែលមានសក្តានុពលគ្មានដែនកំណត់។

លេខកូដកម្មវិធីគឺនៅ Github.
កុំភ្លេចចាប់ផ្តើមម៉ូឌុលរងនៅពេលក្លូនឃ្លាំងនេះ។

PS: វិធីសាស្រ្តទាំងអស់នេះអាចត្រូវបានប្រើជាមួយឧបករណ៍ប្រើប្រាស់ផ្សេងៗ និងភាសាសរសេរកម្មវិធី។ រឿងចំបងគឺថាខ្លឹមសារមិនខុសគ្នាទេ។

ប្រភព: www.habr.com

ទីមួយទ្រឹស្តីតិចតួច។ តើ​មាន​រឿង​អ្វី​កើតឡើង កម្មវិធីដប់ពីរកត្តា?