ការបង្កើតខ្សែសង្វាក់ CI/CD និងដំណើរការដោយស្វ័យប្រវត្តិជាមួយ Docker

ខ្ញុំបានសរសេរគេហទំព័រដំបូងរបស់ខ្ញុំនៅចុងទសវត្សរ៍ទី 90 ។ នៅពេលនោះ វាងាយស្រួលណាស់ក្នុងការដាក់ពួកវាទៅក្នុងលំដាប់ការងារ។ មានម៉ាស៊ីនមេ Apache នៅលើការបង្ហោះចែករំលែកមួយចំនួន អ្នកអាចចូលទៅក្នុងម៉ាស៊ីនមេនេះតាមរយៈ FTP ដោយសរសេរអ្វីមួយដូចជា ftp://ftp.example.com. បន្ទាប់មកអ្នកត្រូវបញ្ចូលឈ្មោះ និងពាក្យសម្ងាត់របស់អ្នក ហើយផ្ទុកឯកសារទៅម៉ាស៊ីនមេ។ មានពេលខុសគ្នា អ្វីៗគឺសាមញ្ញជាងពេលបច្ចុប្បន្ន។

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

សម្រាប់គម្រោងផ្ទាល់ខ្លួនរបស់ខ្ញុំ ខ្ញុំមានការកំណត់រចនាសម្ព័ន្ធពិសេស។ ហើយ​ខ្ញុំ​បាន​ដឹង​ថា​ខ្ញុំ​ត្រូវ​ការ​សមត្ថភាព​ក្នុង​ការ​ដាក់​ពង្រាយ​គេហទំព័រ​ក្នុង​ការ​ផលិត​ដោយ​អនុវត្ត​សកម្មភាព​តែ​មួយ​ប៉ុណ្ណោះ៖ ការ​សរសេរ​កូដ​ទៅ​សាខា master នៅលើ GitHub ។ លើសពីនេះទៀត ខ្ញុំបានដឹងថា ដើម្បីធានាបាននូវប្រតិបត្តិការនៃកម្មវិធីបណ្ដាញតូចរបស់ខ្ញុំ ខ្ញុំមិនចង់គ្រប់គ្រងចង្កោម Kubernetes ដ៏ធំ ឬប្រើបច្ចេកវិទ្យា Docker Swarm ឬរក្សាក្រុមនៃម៉ាស៊ីនមេដែលមានផត ភ្នាក់ងារ និងគ្រប់ប្រភេទផ្សេងទៀត ភាពស្មុគស្មាញ។ ដើម្បីសម្រេចបាននូវគោលដៅនៃការធ្វើឱ្យការងារមានភាពងាយស្រួលតាមដែលអាចធ្វើបាន ខ្ញុំត្រូវស្គាល់ CI/CD ។

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

តម្រូវការជាមុន

អ្នកអានអត្ថបទនេះត្រូវបានគេរំពឹងថានឹងមានការយល់ដឹងជាមូលដ្ឋានអំពីបន្ទាត់ពាក្យបញ្ជា និងការសរសេរអក្សរ Bash ។ លើសពីនេះទៀតគាត់នឹងត្រូវការគណនី Travis CI и ដុកទ័រហាប់.

គោលបំណង

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

នេះជាអ្វីដែលលំហូរការងាររបស់ខ្ញុំបានបញ្ចប់។

សម្រាប់លេខកូដដែលបានបង្ហោះទៅកាន់សាខាឃ្លាំងណាមួយ លើកលែងតែ master, សកម្មភាពខាងក្រោមត្រូវបានអនុវត្ត:

• គម្រោងសាងសង់នៅលើ Travis CI ចាប់ផ្តើម។
• រាល់ឯកតា ការធ្វើសមាហរណកម្ម និងការធ្វើតេស្តពីចុងដល់ចប់ត្រូវបានអនុវត្ត។

សម្រាប់តែលេខកូដដែលធ្លាក់ចូល master, ត្រូវបានអនុវត្តដូចខាងក្រោម:

• អ្វី​គ្រប់​យ៉ាង​ដែល​បាន​រៀបរាប់​ខាង​លើ​, បូក ...
• ការបង្កើតរូបភាព Docker ដោយផ្អែកលើកូដ ការកំណត់ និងបរិស្ថានបច្ចុប្បន្ន។
• ការដាក់ពង្រាយរូបភាពទៅ Docker Hub ។
• ការតភ្ជាប់ទៅម៉ាស៊ីនមេផលិតកម្ម។
• កំពុងបង្ហោះរូបភាពពី Docker Hub ទៅម៉ាស៊ីនមេ។
• ការបញ្ឈប់កុងតឺន័របច្ចុប្បន្ន និងចាប់ផ្តើមថ្មីមួយដោយផ្អែកលើរូបភាពថ្មី។

ប្រសិនបើអ្នកមិនដឹងអ្វីទាំងអស់អំពី Docker រូបភាព និងកុងតឺន័រ កុំបារម្ភ។ ខ្ញុំនឹងប្រាប់អ្នកទាំងអស់គ្នាអំពីវា។

តើ CI/CD ជាអ្វី?

អក្សរកាត់ CI/CD តំណាងឱ្យ "ការរួមបញ្ចូលជាបន្តបន្ទាប់ / ការដាក់ពង្រាយជាបន្តបន្ទាប់" ។

▍ ការរួមបញ្ចូលជាបន្តបន្ទាប់

ការរួមបញ្ចូលជាបន្តបន្ទាប់គឺជាដំណើរការមួយដែលអ្នកអភិវឌ្ឍន៍ធ្វើការប្តេជ្ញាចិត្តចំពោះឃ្លាំងកូដប្រភពសំខាន់របស់គម្រោង (ជាធម្មតាសាខាមួយ master) ទន្ទឹមនឹងនេះគុណភាពនៃលេខកូដត្រូវបានធានាតាមរយៈការធ្វើតេស្តដោយស្វ័យប្រវត្តិ។

▍ ការដាក់ពង្រាយជាបន្តបន្ទាប់

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

ការចាប់ផ្តើម

កម្មវិធីដែលខ្ញុំធ្លាប់រៀនទាំងអស់នេះត្រូវបានគេហៅថា កត់ចំណាំ. នេះគឺជាគម្រោងគេហទំព័រដែលខ្ញុំកំពុងធ្វើការ ដែលត្រូវបានរចនាឡើងសម្រាប់កត់ត្រា។ ដំបូងខ្ញុំព្យាយាមធ្វើ JAMStack-project ឬគ្រាន់តែជាកម្មវិធី front-end ដោយគ្មាន server ដើម្បីទាញយកអត្ថប្រយោជន៍ពីស្តង់ដារ hosting និង project deployment capabilities ដែលវាផ្តល់ជូន Netlify. នៅពេលដែលភាពស្មុគស្មាញនៃកម្មវិធីកើនឡើង ខ្ញុំត្រូវការបង្កើតផ្នែកម៉ាស៊ីនមេរបស់វា ដែលមានន័យថាខ្ញុំនឹងត្រូវបង្កើតយុទ្ធសាស្ត្រផ្ទាល់ខ្លួនរបស់ខ្ញុំសម្រាប់ការរួមបញ្ចូលដោយស្វ័យប្រវត្តិ និងការដាក់ឱ្យប្រើប្រាស់គម្រោងដោយស្វ័យប្រវត្តិ។

ក្នុងករណីរបស់ខ្ញុំ កម្មវិធីគឺជាម៉ាស៊ីនមេ Express ដែលកំពុងដំណើរការនៅក្នុងបរិស្ថាន Node.js បម្រើកម្មវិធី React ទំព័រតែមួយ និងគាំទ្រ API ចំហៀងម៉ាស៊ីនមេដែលមានសុវត្ថិភាព។ ស្ថាបត្យកម្មនេះធ្វើតាមយុទ្ធសាស្រ្តដែលអាចត្រូវបានរកឃើញនៅក្នុង បានផ្តល់ឱ្យ មគ្គុទ្ទេសក៍ការផ្ទៀងផ្ទាត់ជង់ពេញលេញ។

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

Dockers

Docker គឺជាឧបករណ៍ដែលអរគុណចំពោះបច្ចេកវិទ្យា containerization អនុញ្ញាតឱ្យកម្មវិធីត្រូវបានចែកចាយយ៉ាងងាយស្រួលដាក់ពង្រាយ និងដំណើរការក្នុងបរិយាកាសដូចគ្នា ទោះបីជាវេទិកា Docker ខ្លួនវាដំណើរការក្នុងបរិស្ថានផ្សេងគ្នាក៏ដោយ។ ដំបូងខ្ញុំត្រូវយកដៃរបស់ខ្ញុំនៅលើឧបករណ៍បន្ទាត់ពាក្យបញ្ជា Docker (CLI) ។ សេចក្តីណែនាំ មគ្គុទ្ទេសក៍ការដំឡើង Docker មិនអាចត្រូវបានគេហៅថាច្បាស់លាស់ និងអាចយល់បាននោះទេ ប៉ុន្តែពីវា អ្នកអាចរៀនថា ដើម្បីអនុវត្តជំហានដំឡើងដំបូង អ្នកត្រូវទាញយក Docker Desktop (សម្រាប់ Mac ឬ Windows)។

Docker Hub គឺប្រហាក់ប្រហែលនឹង GitHub សម្រាប់ git repositories ឬ registry ម៉ោងងង សម្រាប់កញ្ចប់ JavaScript ។ នេះគឺជាឃ្លាំងលើអ៊ីនធឺណិតសម្រាប់រូបភាព Docker ។ នេះគឺជាអ្វីដែល Docker Desktop ភ្ជាប់ទៅ។

ដូច្នេះ ដើម្បីចាប់ផ្តើមជាមួយ Docker អ្នកត្រូវធ្វើរឿងពីរយ៉ាង៖

• កំណត់ កុំព្យូទ័រលើតុ.
• ចុះឈ្មោះសម្រាប់ ដុកទ័រហាប់.

បន្ទាប់ពីនេះ អ្នកអាចពិនិត្យមើលថាតើ Docker CLI ដំណើរការដោយដំណើរការពាក្យបញ្ជាខាងក្រោមដើម្បីពិនិត្យមើលកំណែ Docker ដែរឬទេ៖

docker -v

បន្ទាប់មក សូមចូលទៅកាន់ Docker Hub ដោយបញ្ចូលឈ្មោះអ្នកប្រើប្រាស់ និងពាក្យសម្ងាត់របស់អ្នក នៅពេលត្រូវបានសួរ៖

docker login

ដើម្បីប្រើ Docker អ្នកត្រូវតែយល់ពីគោលគំនិតនៃរូបភាព និងកុងតឺន័រ។

▍ រូបភាព

រូបភាព​គឺ​ជា​អ្វី​មួយ​ដូច​ជា​ប្លង់​មេ​ដែល​មាន​ការណែនាំ​សម្រាប់​ការ​ដំឡើង​ធុង។ នេះគឺជារូបថតដែលមិនអាចផ្លាស់ប្តូរបាននៃប្រព័ន្ធឯកសារ និងការកំណត់របស់កម្មវិធី។ អ្នកអភិវឌ្ឍន៍អាចចែករំលែករូបភាពបានយ៉ាងងាយស្រួល។

# Вывод сведений обо всех образах
docker images

ពាក្យបញ្ជានេះនឹងបញ្ចេញតារាងដែលមានបឋមកថាដូចខាងក្រោម៖

REPOSITORY     TAG     IMAGE ID     CREATED     SIZE
---

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

▍ ធុង

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

# Перечисление всех контейнеров
docker ps -a
CONTAINER ID     IMAGE     COMMAND     CREATED     STATUS     PORTS     NAMES
---

▍ ស្លាក

ស្លាកគឺជាការចង្អុលបង្ហាញអំពីកំណែជាក់លាក់នៃរូបភាពមួយ។

▍ សេចក្តីយោងរហ័សចំពោះពាក្យបញ្ជា Docker

នេះជាទិដ្ឋភាពទូទៅនៃពាក្យបញ្ជា Docker ដែលប្រើជាទូទៅមួយចំនួន។

ក្រុមការងារ

បរិបទ

ផលប៉ះពាល់

សាងសង់ docker

រូបភាព។

ការបង្កើតរូបភាពពី Dockerfile

ស្លាក docker

រូបភាព។

ការដាក់ស្លាករូបភាព

រូបភាព docker

រូបភាព។

ការចុះបញ្ជីរូបភាព

រត់ docker

កុងតឺន័រ

កំពុងដំណើរការកុងតឺន័រដោយផ្អែកលើរូបភាព

រុញ docker

រូបភាព។

ការបង្ហោះរូបភាពទៅបញ្ជីឈ្មោះ

docker ទាញ

រូបភាព។

កំពុងផ្ទុករូបភាពពីបញ្ជីឈ្មោះ

docker ps

កុងតឺន័រ

ការចុះបញ្ជីធុង

ប្រព័ន្ធ docker កាត់ចេញ

រូបភាព/កុងតឺន័រ

ការដកធុងនិងរូបភាពដែលមិនប្រើ

▍ Dockerfile

ខ្ញុំដឹងពីរបៀបដំណើរការកម្មវិធីផលិតកម្មក្នុងស្រុក។ ខ្ញុំមានការកំណត់រចនាសម្ព័ន្ធ Webpack ដែលត្រូវបានរចនាឡើងដើម្បីបង្កើតកម្មវិធី React ដែលត្រៀមរួចជាស្រេច។ បន្ទាប់មកខ្ញុំមានពាក្យបញ្ជាដែលចាប់ផ្តើមម៉ាស៊ីនមេដែលមានមូលដ្ឋានលើ Node.js នៅលើច្រក 5000. វាមើលទៅដូចនេះ៖

npm i         # установка зависимостей
npm run build # сборка React-приложения
npm run start # запуск Node-сервера

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

ដើម្បីប្រើកុងតឺន័រ អ្នកនឹងត្រូវផ្តល់ការណែនាំដល់ Docker ។ នេះត្រូវបានធ្វើតាមរយៈឯកសារដែលហៅថា Dockerfileដែលមានទីតាំងនៅក្នុងថតឫសនៃគម្រោង។ ដំបូងឯកសារនេះហាក់ដូចជាមិនអាចយល់បាន។

ប៉ុន្តែអ្វីដែលវាមានពណ៌នាតែប៉ុណ្ណោះ ជាមួយនឹងពាក្យបញ្ជាពិសេស ដែលស្រដៀងនឹងការរៀបចំបរិយាកាសការងារ។ នេះគឺជាពាក្យបញ្ជាមួយចំនួន៖

• FROM - ពាក្យបញ្ជានេះចាប់ផ្តើមឯកសារ។ វាបញ្ជាក់រូបភាពមូលដ្ឋានដែលធុងត្រូវបានសាងសង់។
• ច្បាប់ចម្លង - ចម្លងឯកសារពីប្រភពក្នុងស្រុកទៅកុងតឺន័រ។
• WORKDIR - កំណត់ថតការងារសម្រាប់ពាក្យបញ្ជាខាងក្រោម។
• រត់ - ដំណើរការពាក្យបញ្ជា។
• ការពន្យល់ - ការកំណត់ច្រក។
• ចំណុច​ចូល - ការចង្អុលបង្ហាញអំពីពាក្យបញ្ជាដែលត្រូវប្រតិបត្តិ។

Dockerfile អាចមើលទៅដូចនេះ៖

# Загрузить базовый образ
FROM node:12-alpine

# Скопировать файлы из текущей директории в директорию app/
COPY . app/

# Использовать app/ в роли рабочей директории
WORKDIR app/

# Установить зависимости (команда npm ci похожа npm i, но используется для автоматизированных сборок)
RUN npm ci --only-production

# Собрать клиентское React-приложение для продакшна
RUN npm run build

# Прослушивать указанный порт
EXPOSE 5000

# Запустить Node-сервер
ENTRYPOINT npm run start

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

▍ ការសាងសង់ ការដាក់ស្លាក និងដំណើរការកុងតឺន័រ

ការជួបប្រជុំគ្នាក្នុងតំបន់និងការបើកដំណើរការកុងតឺន័រគឺបន្ទាប់ពីយើងមាន Dockerfile, ភារកិច្ចគឺសាមញ្ញណាស់។ មុនពេលអ្នករុញរូបភាពទៅ Docker Hub អ្នកត្រូវសាកល្បងវានៅក្នុងមូលដ្ឋាន។

▍ សន្និបាត

ដំបូងអ្នកត្រូវប្រមូល រូបភាពមួយការបញ្ជាក់ឈ្មោះ និងជាជម្រើស ស្លាក (ប្រសិនបើស្លាកមិនត្រូវបានបញ្ជាក់ទេ ប្រព័ន្ធនឹងកំណត់ស្លាកដោយស្វ័យប្រវត្តិទៅរូបភាព latest).

# Сборка образа
docker build -t <image>:<tag> .

បន្ទាប់ពីដំណើរការពាក្យបញ្ជានេះ អ្នកអាចមើល Docker បង្កើតរូបភាព។

Sending build context to Docker daemon   2.88MB
Step 1/9 : FROM node:12-alpine
 ---> ...выполнение этапов сборки...
Successfully built 123456789123
Successfully tagged <image>:<tag>

ការសាងសង់អាចចំណាយពេលពីរបីនាទី - វាទាំងអស់គឺអាស្រ័យលើចំនួនភាពអាស្រ័យដែលអ្នកមាន។ នៅពេលដែលការស្ថាបនាត្រូវបានបញ្ចប់អ្នកអាចដំណើរការពាក្យបញ្ជា docker images ហើយមើលការពិពណ៌នានៃរូបភាពថ្មីរបស់អ្នក។

REPOSITORY          TAG               IMAGE ID            CREATED              SIZE
<image>             latest            123456789123        About a minute ago   x.xxGB

▍ បើកដំណើរការ

រូបភាពត្រូវបានបង្កើតឡើង។ នេះមានន័យថាអ្នកអាចដំណើរការកុងតឺន័រដោយផ្អែកលើវា។ ដោយសារតែខ្ញុំចង់អាចចូលទៅកាន់កម្មវិធីដែលកំពុងដំណើរការនៅក្នុងកុងតឺន័រនៅ localhost:5000, ខ្ញុំ, នៅខាងឆ្វេងនៃគូ 5000:5000 នៅក្នុងពាក្យបញ្ជាបន្ទាប់ដែលបានដំឡើង 5000. នៅខាងស្តាំគឺជាច្រកកុងតឺន័រ។

# Запуск с использованием локального порта 5000 и порта контейнера 5000
docker run -p 5000:5000 <image>:<tag>

ឥឡូវនេះកុងតឺន័រត្រូវបានបង្កើត និងដំណើរការ អ្នកអាចប្រើពាក្យបញ្ជា docker ps ដើម្បីមើលព័ត៌មានអំពីធុងនេះ (ឬអ្នកអាចប្រើពាក្យបញ្ជា docker ps -aដែលបង្ហាញព័ត៌មានអំពីកុងតឺន័រទាំងអស់ មិនត្រឹមតែដំណើរការប៉ុណ្ណោះទេ)។

CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS                      PORTS                    NAMES
987654321234        <image>             "/bin/sh -c 'npm run…"   6 seconds ago        Up 6 seconds                0.0.0.0:5000->5000/tcp   stoic_darwin

ប្រសិនបើអ្នកឥឡូវនេះទៅអាសយដ្ឋាន localhost:5000 — អ្នកអាចឃើញទំព័រនៃកម្មវិធីដែលកំពុងដំណើរការដែលមើលទៅដូចគ្នាទៅនឹងទំព័រនៃកម្មវិធីដែលកំពុងដំណើរការនៅក្នុងបរិយាកាសផលិតកម្ម។

▍ ការដាក់ស្លាក និងការបោះពុម្ពផ្សាយ

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

ឥឡូវអ្នកអាចបង្កើតរូបភាពដោយប្រើឈ្មោះថ្មី ហើយដំណើរការពាក្យបញ្ជា docker push ដើម្បីរុញវាទៅឃ្លាំង Docker Hub ។

docker build -t <username>/<repository>:<tag> .
docker tag <username>/<repository>:<tag> <username>/<repository>:latest
docker push <username>/<repository>:<tag>

# На практике это может выглядеть, например, так:
docker build -t user/app:v1.0.0 .
docker tag user/app:v1.0.0 user/app:latest
docker push user/app:v1.0.0

ប្រសិនបើអ្វីៗដំណើរការល្អ រូបភាពនឹងមាននៅលើ Docker Hub ហើយអាចផ្ទុកឡើងយ៉ាងងាយស្រួលទៅកាន់ម៉ាស៊ីនមេ ឬផ្ទេរទៅអ្នកអភិវឌ្ឍន៍ផ្សេងទៀត។

ជំហាន​បន្ទាប់

មកដល់ពេលនេះ យើងបានផ្ទៀងផ្ទាត់ថាកម្មវិធីក្នុងទម្រង់ជា Docker container កំពុងដំណើរការក្នុងមូលដ្ឋាន។ យើងបានបង្ហោះកុងតឺន័រទៅ Docker Hub ។ ទាំងអស់នេះមានន័យថា ពួកយើងបានឈានទៅមុខយ៉ាងល្អ ឆ្ពោះទៅរកគោលដៅរបស់យើង។ ឥឡូវនេះយើងត្រូវដោះស្រាយសំណួរពីរបន្ថែមទៀត៖

• ការដំឡើងឧបករណ៍ CI សម្រាប់សាកល្បង និងដាក់ពង្រាយកូដ។
• ការដំឡើងម៉ាស៊ីនមេផលិតកម្មដើម្បីឱ្យវាអាចទាញយក និងដំណើរការកូដរបស់យើង។

ក្នុងករណីរបស់យើងយើងប្រើ Travis CI. ជាម៉ាស៊ីនមេ - ឌីទីហ្គាលមហាសមុទ្រ.

វាគួរតែត្រូវបានកត់សម្គាល់ថានៅទីនេះអ្នកអាចប្រើការរួមបញ្ចូលគ្នានៃសេវាកម្មផ្សេងទៀត។ ឧទាហរណ៍ ជំនួសឱ្យ Travis CI អ្នកអាចប្រើ CircleCI ឬ Github Actions ។ ហើយជំនួសឱ្យ DigitalOcean - AWS ឬ Linode ។

យើងបានសម្រេចចិត្តធ្វើការជាមួយ Travis CI ហើយខ្ញុំមានអ្វីមួយដែលបានកំណត់រចនាសម្ព័ន្ធរួចហើយនៅក្នុងសេវាកម្មនេះ។ ដូច្នេះឥឡូវនេះខ្ញុំនឹងនិយាយដោយសង្ខេបអំពីរបៀបរៀបចំវាសម្រាប់ការងារ។

Travis CI

Travis CI គឺជាឧបករណ៍សម្រាប់សាកល្បង និងដាក់ពង្រាយកូដ។ ខ្ញុំមិនចង់ចូលទៅក្នុងភាពស្មុគ្រស្មាញនៃការបង្កើត Travis CI ទេ ដោយសារគម្រោងនីមួយៗមានលក្ខណៈពិសេស ហើយវានឹងមិននាំមកនូវអត្ថប្រយោជន៍ច្រើនទេ។ ប៉ុន្តែខ្ញុំនឹងរៀបរាប់ពីមូលដ្ឋានគ្រឹះ ដើម្បីឲ្យអ្នកចាប់ផ្តើម ប្រសិនបើអ្នកសម្រេចចិត្តប្រើ Travis CI។ មិនថាអ្នកជ្រើសរើស Travis CI, CircleCI, Jenkins ឬអ្វីផ្សេងទៀតទេ វិធីសាស្ត្រកំណត់រចនាសម្ព័ន្ធស្រដៀងគ្នានឹងត្រូវបានប្រើនៅគ្រប់ទីកន្លែង។

ដើម្បីចាប់ផ្តើមជាមួយ Travis CI សូមចូលទៅកាន់ គេហទំព័រគម្រោង និងបង្កើតគណនីមួយ។ បន្ទាប់មកបញ្ចូល Travis CI ជាមួយគណនី GitHub របស់អ្នក។ នៅពេលដំឡើងប្រព័ន្ធ អ្នកនឹងត្រូវបញ្ជាក់ឃ្លាំងដែលអ្នកចង់ធ្វើការដោយស្វ័យប្រវត្តិ និងបើកការចូលប្រើវា។ (ខ្ញុំប្រើ GitHub ប៉ុន្តែខ្ញុំប្រាកដថា Travis CI អាចរួមបញ្ចូលជាមួយ BitBucket និង GitLab និងសេវាកម្មស្រដៀងគ្នាផ្សេងទៀត)។

រាល់ពេលដែល Travis CI ត្រូវបានចាប់ផ្តើម ម៉ាស៊ីនមេត្រូវបានបើកដំណើរការ ដោយប្រតិបត្តិពាក្យបញ្ជាដែលបានបញ្ជាក់នៅក្នុងឯកសារកំណត់រចនាសម្ព័ន្ធ រួមទាំងការដាក់ពង្រាយសាខាឃ្លាំងដែលត្រូវគ្នា។

▍ វដ្តជីវិតការងារ

ឯកសារកំណត់រចនាសម្ព័ន្ធ Travis CI បានហៅ .travis.yml និងរក្សាទុកក្នុងថតឫសគម្រោង គាំទ្រគំនិតនៃព្រឹត្តិការណ៍ វដ្ដ​ជីវិត ភារកិច្ច។ ព្រឹត្តិការណ៍ទាំងនេះត្រូវបានរាយក្នុងលំដាប់ដែលវាកើតឡើង៖

• apt addons
• cache components
• before_install
• install
• before_script
• script
• before_cache
• after_success или after_failure
• before_deploy
• deploy
• after_deploy
• after_script

▍ ការធ្វើតេស្ត

នៅក្នុងឯកសារកំណត់រចនាសម្ព័ន្ធ ខ្ញុំនឹងកំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនមេ Travis CI មូលដ្ឋាន។ ខ្ញុំបានជ្រើសរើស Node 12 ជាភាសា ហើយបានប្រាប់ប្រព័ន្ធឱ្យដំឡើងភាពអាស្រ័យដែលតម្រូវឱ្យប្រើ Docker ។

អ្វីគ្រប់យ៉ាងដែលមាននៅក្នុងបញ្ជី .travis.ymlនឹងត្រូវបានប្រតិបត្តិនៅពេលដែលសំណើទាញទាំងអស់ត្រូវបានធ្វើឡើងទៅកាន់គ្រប់សាខាទាំងអស់នៃឃ្លាំង លើកលែងតែមានការបញ្ជាក់ផ្សេងពីនេះ។ នេះគឺជាមុខងារមានប្រយោជន៍ព្រោះវាមានន័យថាយើងអាចសាកល្បងកូដទាំងអស់ដែលចូលមកក្នុងឃ្លាំង។ នេះអនុញ្ញាតឱ្យអ្នកដឹងថាតើកូដរួចរាល់ហើយឬនៅដើម្បីសរសេរទៅកាន់សាខា។ masterនិងថាតើវានឹងបំបែកដំណើរការសាងសង់គម្រោងដែរឬទេ។ នៅក្នុងការកំណត់រចនាសម្ព័ន្ធសកលនេះ ខ្ញុំដំឡើងអ្វីៗគ្រប់យ៉ាងនៅក្នុងមូលដ្ឋាន ដំណើរការម៉ាស៊ីនមេ Webpack dev ក្នុងផ្ទៃខាងក្រោយ (នេះគឺជាលក្ខណៈនៃដំណើរការការងាររបស់ខ្ញុំ) និងដំណើរការសាកល្បង។

ប្រសិនបើអ្នកចង់ឱ្យឃ្លាំងរបស់អ្នកបង្ហាញរូបតំណាងគ្របដណ្តប់សាកល្បង, នៅទីនេះ អ្នកអាចស្វែងរកការណែនាំខ្លីៗស្តីពីការប្រើប្រាស់ Jest, Travis CI និង Coveralls ដើម្បីប្រមូល និងបង្ហាញព័ត៌មាននេះ។

ដូច្នេះនេះគឺជាខ្លឹមសារនៃឯកសារ .travis.yml:

# Установить язык
language: node_js

# Установить версию Node.js
node_js:
  - '12'

services:
  # Использовать командную строку Docker
  - docker

install:
  # Установить зависимости для тестов
  - npm ci

before_script:
  # Запустить сервер и клиент для тестов
  - npm run dev &

script:
  # Запустить тесты
  - npm run test

នេះគឺជាកន្លែងដែលសកម្មភាពដែលត្រូវបានអនុវត្តសម្រាប់សាខាទាំងអស់នៃឃ្លាំង និងសម្រាប់សំណើទាញបញ្ចប់។

▍ ការដាក់ពង្រាយ

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

deploy:
  # Собрать Docker-контейнер и отправить его на Docker Hub
  provider: script
  script: bash deploy.sh
  on:
    branch: master

ស្គ្រីបដាក់ពង្រាយដោះស្រាយបញ្ហាពីរ៖

• បង្កើត ដាក់ស្លាក និងផ្ញើរូបភាពទៅ Docker Hub ដោយប្រើឧបករណ៍ CI (ក្នុងករណីរបស់យើង Travis CI)។
• កំពុងផ្ទុករូបភាពនៅលើម៉ាស៊ីនមេ បញ្ឈប់កុងតឺន័រចាស់ និងចាប់ផ្តើមថ្មីមួយ (ក្នុងករណីរបស់យើង ម៉ាស៊ីនមេដំណើរការលើវេទិកា DigitalOcean)។

ដំបូង អ្នក​ត្រូវ​រៀបចំ​ដំណើរការ​ស្វ័យ​ប្រវត្តិ​សម្រាប់​ការ​បង្កើត ការ​ដាក់​ស្លាក និង​រុញ​រូបភាព​ទៅ Docker Hub។ ទាំងអស់នេះគឺស្រដៀងគ្នាទៅនឹងអ្វីដែលយើងបានធ្វើរួចដោយដៃ លើកលែងតែយើងត្រូវការយុទ្ធសាស្ត្រសម្រាប់កំណត់ស្លាកតែមួយគត់ទៅរូបភាព និងការចូលដោយស្វ័យប្រវត្តិ។ ខ្ញុំមានការពិបាកជាមួយនឹងព័ត៌មានលម្អិតមួយចំនួននៃស្គ្រីបដាក់ឱ្យប្រើប្រាស់ ដូចជាយុទ្ធសាស្ត្រដាក់ស្លាក ការចូល ការអ៊ិនកូដ SSH key ការបង្កើតការតភ្ជាប់ SSH ។ ប៉ុន្តែ​សំណាង​ល្អ​ដែល​មិត្ត​ប្រុស​របស់​ខ្ញុំ​ល្អ​ជាមួយ​នឹង bash ដូច​នឹង​រឿង​ជា​ច្រើន​ទៀត។ គាត់បានជួយខ្ញុំសរសេរស្គ្រីបនេះ។

ដូច្នេះ ផ្នែកដំបូងនៃស្គ្រីបកំពុងផ្ទុករូបភាពទៅ Docker Hub ។ នេះពិតជាងាយស្រួលធ្វើ។ គ្រោងការណ៍ដាក់ស្លាកដែលខ្ញុំបានប្រើពាក់ព័ន្ធនឹងការរួមបញ្ចូល git hash និង git tag ប្រសិនបើមាន។ នេះធានាថាស្លាកគឺមានតែមួយគត់ និងធ្វើឱ្យវាកាន់តែងាយស្រួលក្នុងការកំណត់អត្តសញ្ញាណការជួបប្រជុំគ្នាដែលវាមានមូលដ្ឋាន។ DOCKER_USERNAME и DOCKER_PASSWORD គឺជាអថេរបរិស្ថានអ្នកប្រើប្រាស់ដែលអាចកំណត់ដោយប្រើចំណុចប្រទាក់ Travis CI ។ Travis CI នឹងដំណើរការទិន្នន័យរសើបដោយស្វ័យប្រវត្តិ ដើម្បីកុំឱ្យវាធ្លាក់ទៅក្នុងដៃខុស។

នេះគឺជាផ្នែកដំបូងនៃស្គ្រីប deploy.sh.

#!/bin/sh
set -e # Остановить скрипт при наличии ошибок

IMAGE="<username>/<repository>"                             # Образ Docker
GIT_VERSION=$(git describe --always --abbrev --tags --long) # Git-хэш и теги

# Сборка и тегирование образа
docker build -t ${IMAGE}:${GIT_VERSION} .
docker tag ${IMAGE}:${GIT_VERSION} ${IMAGE}:latest

# Вход в Docker Hub и выгрузка образа
echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
docker push ${IMAGE}:${GIT_VERSION}

អ្វីដែលផ្នែកទីពីរនៃស្គ្រីបនឹងអាស្រ័យទាំងស្រុងលើម៉ាស៊ីនដែលអ្នកកំពុងប្រើ និងរបៀបដែលការតភ្ជាប់ទៅវាត្រូវបានរៀបចំ។ ក្នុងករណីរបស់ខ្ញុំ ដោយសារខ្ញុំប្រើ Digital Ocean ខ្ញុំប្រើពាក្យបញ្ជាដើម្បីភ្ជាប់ទៅម៉ាស៊ីនមេ បណ្ឌិត. នៅពេលធ្វើការជាមួយ AWS ឧបករណ៍ប្រើប្រាស់នឹងត្រូវបានប្រើ aws, ល​ល។

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

ខ្ញុំមិននិយាយនៅទីនេះអំពីពាក្យបញ្ជាជាក់លាក់សម្រាប់សេវាកម្មទេ ព្រោះទិដ្ឋភាពនេះអាចប្រែប្រួលយ៉ាងខ្លាំងនៅក្នុងករណីផ្សេងៗគ្នា។ ខ្ញុំនឹងផ្តល់ផែនការទូទៅនៃសកម្មភាពដែលត្រូវអនុវត្តបន្ទាប់ពីភ្ជាប់តាមរយៈ SSH ទៅម៉ាស៊ីនមេ ដែលគម្រោងនេះនឹងត្រូវដាក់ឱ្យប្រើប្រាស់៖

• យើងត្រូវស្វែងរកកុងតឺន័រដែលកំពុងដំណើរការហើយបញ្ឈប់វា។
• បន្ទាប់មកអ្នកត្រូវបើកដំណើរការកុងតឺន័រថ្មីមួយនៅផ្ទៃខាងក្រោយ។
• អ្នកនឹងត្រូវកំណត់ច្រកមូលដ្ឋានរបស់ម៉ាស៊ីនមេ 80 - វានឹងអនុញ្ញាតឱ្យអ្នកបញ្ចូលគេហទំព័រនៅអាសយដ្ឋានដូច example.comដោយមិនបញ្ជាក់ច្រក ជាជាងប្រើអាសយដ្ឋានដូច example.com:5000.
• ជាចុងក្រោយ អ្នកត្រូវលុបធុង និងរូបភាពចាស់ៗទាំងអស់ចេញ។

នេះគឺជាការបន្តនៃស្គ្រីប។

# Найти ID работающего контейнера
CONTAINER_ID=$(docker ps | grep takenote | cut -d" " -f1)

# Остановить старый контейнер, запустить новый, очистить систему
docker stop ${CONTAINER_ID}
docker run --restart unless-stopped -d -p 80:5000 ${IMAGE}:${GIT_VERSION}
docker system prune -a -f

រឿងមួយចំនួនដែលត្រូវយកចិត្តទុកដាក់

វាអាចទៅរួចដែលថានៅពេលដែលអ្នកភ្ជាប់ទៅម៉ាស៊ីនមេតាមរយៈ SSH ពី Travis CI អ្នកនឹងឃើញការព្រមានដែលនឹងរារាំងអ្នកពីការបន្តការដំឡើងព្រោះប្រព័ន្ធនឹងរង់ចាំការឆ្លើយតបរបស់អ្នកប្រើប្រាស់។

The authenticity of host '<hostname> (<IP address>)' can't be established.
RSA key fingerprint is <key fingerprint>.
Are you sure you want to continue connecting (yes/no)?

ខ្ញុំ​បាន​រៀន​ថា string key អាច​ត្រូវ​បាន​អ៊ិនកូដ​ក្នុង base64 ដើម្បី​រក្សា​ទុក​វា​ក្នុង​ទម្រង់​ដែល​វា​អាច​ធ្វើ​ការ​បាន​យ៉ាង​ងាយស្រួល និង​អាច​ទុក​ចិត្ត​បាន។ នៅ​ដំណាក់កាល​ដំឡើង អ្នក​អាច​ឌិកូដ​សោសាធារណៈ ហើយ​សរសេរ​វា​ទៅ​ឯកសារ known_hosts ដើម្បីកម្ចាត់កំហុសខាងលើ។

echo <public key> | base64 # выводит <публичный ключ, закодированный в base64>

នៅក្នុងការអនុវត្ត ពាក្យបញ្ជានេះអាចមើលទៅដូចនេះ៖

echo "123.45.67.89 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAklOUpkDHrfHY17SbrmTIpNLTGK9Tjom/BWDSU
GPl+nafzlHDTYW7hdI4yZ5ew18JH4JW9jbhUFrviQzM7xlELEVf4h9lFX5QVkbPppSwg0cda3
Pbv7kOdJ/MTyBlWXFCR+HAo3FXRitBqxiX1nKhXpHAZsMciLq8V6RjsNAQwdsdMFvSlVK/7XA
t3FaoJoAsncM1Q9x5+3V0Ww68/eIFmb1zuUFljQJKprrX88XypNDvjYNby6vw/Pb0rwert/En
mZ+AW4OZPnTPI89ZPmVMLuayrD2cE86Z/il8b+gw3r3+1nKatmIkjn2so1d01QraTlMqVSsbx
NrRFi9wrf+M7Q== [email protected]" | base64

ហើយនេះគឺជាអ្វីដែលវាផលិត - ខ្សែអក្សរដែលបានអ៊ិនកូដ base64៖

MTIzLjQ1LjY3Ljg5IHNzaC1yc2EgQUFBQUIzTnphQzF5YzJFQUFBQUJJd0FBQVFFQWtsT1Vwa0RIcmZIWTE3U2JybVRJcE5MVEdLOVRqb20vQldEU1UKR1BsK25hZnpsSERUWVc3aGRJNHlaNWV3MThKSDRKVzlqYmhVRnJ2aVF6TTd4bEVMRVZmNGg5bEZYNVFWa2JQcHBTd2cwY2RhMwpQYnY3a09kSi9NVHlCbFdYRkNSK0hBbzNGWFJpdEJxeGlYMW5LaFhwSEFac01jaUxxOFY2UmpzTkFRd2RzZE1GdlNsVksvN1hBCnQzRmFvSm9Bc25jTTFROXg1KzNWMFd3NjgvZUlGbWIxenVVRmxqUUpLcHJyWDg4WHlwTkR2allOYnk2dncvUGIwcndlcnQvRW4KbVorQVc0T1pQblRQSTg5WlBtVk1MdWF5ckQyY0U4NlovaWw4YitndzNyMysxbkthdG1Ja2puMnNvMWQwMVFyYVRsTXFWU3NieApOclJGaTl3cmYrTTdRPT0geW91QGV4YW1wbGUuY29tCg==

នេះគឺជាពាក្យបញ្ជាដែលបានរៀបរាប់ខាងលើ

install:
  - echo < публичный ключ, закодированный в base64> | base64 -d >> $HOME/.ssh/known_hosts

វិធីសាស្រ្តដូចគ្នានេះអាចត្រូវបានប្រើជាមួយសោឯកជននៅពេលបង្កើតការតភ្ជាប់ ដោយសារអ្នកប្រហែលជាត្រូវការសោឯកជនដើម្បីចូលប្រើម៉ាស៊ីនមេ។ នៅពេលធ្វើការជាមួយសោ អ្នកគ្រាន់តែត្រូវធានាថាវាត្រូវបានរក្សាទុកយ៉ាងមានសុវត្ថិភាពនៅក្នុងបរិស្ថាន Travis CI ហើយថាវាមិនត្រូវបានបង្ហាញគ្រប់ទីកន្លែងទេ។

រឿងមួយទៀតដែលត្រូវកត់សម្គាល់គឺថាអ្នកប្រហែលជាត្រូវដំណើរការស្គ្រីបការដាក់ពង្រាយទាំងមូលជាបន្ទាត់មួយឧទាហរណ៍ - ជាមួយ doctl. នេះអាចតម្រូវឱ្យមានការខិតខំប្រឹងប្រែងបន្ថែមមួយចំនួន។

doctl compute ssh <droplet> --ssh-command "все команды будут здесь && здесь"

TLS/SSL និងការផ្ទុកតុល្យភាព

បន្ទាប់​ពី​ខ្ញុំ​បាន​ធ្វើ​អ្វី​គ្រប់​យ៉ាង​ដែល​បាន​រៀបរាប់​ខាង​លើ បញ្ហា​ចុង​ក្រោយ​ដែល​ខ្ញុំ​បាន​ជួប​គឺ​ម៉ាស៊ីន​បម្រើ​មិន​មាន SSL ។ ដោយសារខ្ញុំប្រើម៉ាស៊ីនមេ Node.js ដើម្បីបង្ខំ ធ្វើការ ប្រូកស៊ីបញ្ច្រាស Nginx និង Let's Encrypt អ្នកត្រូវ tinker ច្រើន។

ខ្ញុំពិតជាមិនចង់ធ្វើការកំណត់រចនាសម្ព័ន្ធ SSL នេះដោយដៃទេ ដូច្នេះខ្ញុំទើបតែបង្កើតកម្មវិធីតុល្យភាពបន្ទុក និងកត់ត្រាព័ត៌មានលម្អិតរបស់វានៅក្នុង DNS ។ ឧទាហរណ៍ក្នុងករណី DigitalOcean ការបង្កើតវិញ្ញាបនបត្រដែលចុះហត្ថលេខាដោយខ្លួនឯងដែលបន្តដោយស្វ័យប្រវត្តិនៅលើឧបករណ៍ផ្ទុកតុល្យភាពគឺជានីតិវិធីសាមញ្ញ ឥតគិតថ្លៃ និងលឿន។ វិធីសាស្រ្តនេះមានអត្ថប្រយោជន៍បន្ថែមដែលវាធ្វើឱ្យមានភាពងាយស្រួលក្នុងការដំឡើង SSL នៅលើម៉ាស៊ីនមេជាច្រើនដែលដំណើរការនៅពីក្រោយឧបករណ៍ផ្ទុកតុល្យភាពប្រសិនបើចាំបាច់។ នេះអនុញ្ញាតឱ្យម៉ាស៊ីនមេខ្លួនឯងមិន "គិត" អំពី SSL ទាល់តែសោះ ប៉ុន្តែក្នុងពេលតែមួយប្រើច្រកដូចធម្មតា 80. ដូច្នេះការដំឡើង SSL នៅលើ load balancer គឺកាន់តែងាយស្រួល និងងាយស្រួលជាងវិធីសាស្រ្តផ្សេងទៀតនៃការដំឡើង SSL ។

ឥឡូវនេះអ្នកអាចបិទច្រកទាំងអស់នៅលើម៉ាស៊ីនមេដែលទទួលយកការតភ្ជាប់ចូល - លើកលែងតែច្រក 80ប្រើដើម្បីទាក់ទងជាមួយ Load Balancer និង Port 22 សម្រាប់ SSH ។ ជាលទ្ធផល ការព្យាយាមចូលប្រើម៉ាស៊ីនមេដោយផ្ទាល់នៅលើច្រកណាមួយក្រៅពីច្រកទាំងពីរនេះនឹងបរាជ័យ។

លទ្ធផល

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

PS នៅក្នុងរបស់យើង ទីផ្សារ មានរូបភាពមួយ។ Dockersដែលអាចត្រូវបានដំឡើងដោយចុចតែម្តង។ អ្នកអាចពិនិត្យមើលប្រតិបត្តិការនៃធុងនៅ ការ VPS. អតិថិជនថ្មីទាំងអស់ត្រូវបានផ្តល់ការសាកល្បងរយៈពេល 3 ថ្ងៃដោយមិនគិតថ្លៃ។

អ្នកអានជាទីស្រឡាញ់! តើអ្នកប្រើបច្ចេកវិទ្យា CI/CD នៅក្នុងគម្រោងរបស់អ្នកទេ?

ប្រភព: www.habr.com