VM ឬ Docker?

តើធ្វើដូចម្តេចដើម្បីយល់ថាអ្នកត្រូវការ Docker ហើយមិនមែនជា VM? អ្នក​ត្រូវ​កំណត់​នូវ​អ្វី​ដែល​អ្នក​ចង់​នៅ​ដាច់​ដោយ​ឡែក។ ប្រសិនបើអ្នកចង់ផ្តាច់ប្រព័ន្ធដែលមានធនធានធានា និងផ្នែករឹងនិម្មិត នោះជម្រើសគួរតែស្ថិតនៅលើ VM ។ ប្រសិនបើអ្នកត្រូវការផ្តាច់កម្មវិធីដែលកំពុងដំណើរការជាដំណើរការប្រព័ន្ធដាច់ដោយឡែក អ្នកនឹងត្រូវការ Docker ។

ដូច្នេះតើអ្វីជាភាពខុសគ្នារវាង Docker containers និង VMs?

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

• ទំហំថាសរឹងថេរ ដែលអនុញ្ញាតឱ្យចូលប្រើថាសរឹងនិម្មិតលឿនជាងមុន និងជៀសវាងការបំបែកឯកសារ។
• ការបែងចែកអង្គចងចាំថាមវន្ត។ នៅពេលដំឡើងកម្មវិធីបន្ថែម អង្គចងចាំនឹងត្រូវបានបែងចែកជាថាមវន្តសម្រាប់ពួកវា រហូតដល់វាឈានដល់ចំនួនអតិបរមាដែលបានបម្រុងទុកសម្រាប់វា។

ម៉ាស៊ីននិម្មិតកាន់តែច្រើននៅលើម៉ាស៊ីនមេ កន្លែងទំនេរកាន់តែច្រើន ហើយត្រូវការការគាំទ្រជាប្រចាំនៃបរិស្ថានដែលត្រូវការសម្រាប់កម្មវិធីរបស់អ្នកដើម្បីដំណើរការ។

Dockers គឺជាកម្មវិធីសម្រាប់បង្កើតកម្មវិធីដោយផ្អែកលើកុងតឺន័រ។ កុងតឺន័រ និងម៉ាស៊ីននិម្មិតមានអត្ថប្រយោជន៍ស្រដៀងគ្នា ប៉ុន្តែដំណើរការខុសគ្នា។ កុងតឺន័រប្រើប្រាស់កន្លែងទំនេរតិច ពីព្រោះ ប្រើប្រាស់ធនធានដែលបានចែករំលែកច្រើនជាងប្រព័ន្ធម៉ាស៊ីនជាង VM ពីព្រោះ មិនដូច VM ទេ ផ្តល់នូវនិម្មិតនៅកម្រិត OS មិនមែន hardware ទេ។ វិធីសាស្រ្តនេះផ្តល់នូវការចងចាំតិច ការដាក់ពង្រាយកាន់តែលឿន និងការធ្វើមាត្រដ្ឋានកាន់តែងាយស្រួល។

កុងតឺន័រផ្តល់នូវយន្តការដ៏មានប្រសិទ្ធភាពជាងមុនសម្រាប់ការវេចខ្ចប់កម្មវិធីដោយផ្តល់នូវចំណុចប្រទាក់ចាំបាច់ដល់ប្រព័ន្ធម៉ាស៊ីន។ លក្ខណៈពិសេសនេះអនុញ្ញាតឱ្យកុងតឺន័រចែករំលែកស្នូលនៃប្រព័ន្ធ ដែលកុងតឺន័រនីមួយៗដំណើរការជាដំណើរការដាច់ដោយឡែកនៃប្រព័ន្ធប្រតិបត្តិការចម្បង ដែលមានសំណុំនៃតំបន់សតិផ្ទាល់ខ្លួន (ទំហំអាសយដ្ឋាននិម្មិតរបស់វាផ្ទាល់)។ ដោយសារទំហំអាសយដ្ឋាននិម្មិតរបស់កុងតឺន័រនីមួយៗគឺជារបស់វា ទិន្នន័យដែលជាកម្មសិទ្ធិរបស់តំបន់អង្គចងចាំផ្សេងៗគ្នាមិនអាចផ្លាស់ប្តូរបានទេ។
ប្រព័ន្ធប្រតិបត្តិការដើមសម្រាប់ Docker គឺលីនុច (Docker ក៏អាចប្រើនៅលើ Windows និង MacOS) វាប្រើគុណសម្បត្តិចម្បងរបស់វា ដែលអនុញ្ញាតឱ្យវារៀបចំខឺណែលបំបែក។ ការបើកដំណើរការ Docker containers នៅលើ Windows នឹងធ្វើឡើងនៅក្នុងម៉ាស៊ីននិម្មិត Linux ពីព្រោះ containers ចែករំលែក OS នៃប្រព័ន្ធ host ហើយ OS សំខាន់សម្រាប់ពួកគេគឺ Linux ។

កុងតឺន័រ - តើវាដំណើរការយ៉ាងដូចម្តេច?

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

កុងតឺន័រនីមួយៗអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធតាមរយៈឯកសារនៅក្នុងគម្រោង docker-compose ដែលរួមបញ្ចូលនៅក្នុងដំណោះស្រាយចម្បង docker-compose.yml ។ នៅទីនោះអ្នកអាចកំណត់ប៉ារ៉ាម៉ែត្រផ្សេងៗដូចជាឈ្មោះកុងតឺន័រ ច្រក ការកំណត់អត្តសញ្ញាណ ដែនកំណត់ធនធាន ភាពអាស្រ័យរវាងកុងតឺន័រផ្សេងទៀត។ ប្រសិនបើអ្នកមិនបញ្ជាក់ឈ្មោះកុងតឺន័រក្នុងការកំណត់ទេ នោះ Docker នឹងបង្កើតកុងតឺន័រថ្មីរាល់ពេល ដោយកំណត់ឈ្មោះឱ្យវាដោយចៃដន្យ។

នៅពេលដែលកុងតឺន័រត្រូវបានចាប់ផ្តើមពីរូបភាព Docker ដំឡើងប្រព័ន្ធឯកសារអាន/សរសេរនៅលើកំពូលនៃស្រទាប់ខាងក្រោម។ នេះគឺជាកន្លែងដែលដំណើរការទាំងអស់ដែលយើងចង់ឱ្យ Docker container របស់យើងដំណើរការនឹងដំណើរការ។

នៅពេលដែល Docker ចាប់ផ្តើមកុងតឺន័រដំបូង ស្រទាប់អាន/សរសេរដំបូងគឺទទេ។ នៅពេលដែលការផ្លាស់ប្តូរកើតឡើងពួកវាត្រូវបានអនុវត្តទៅស្រទាប់នោះ; ឧទាហរណ៍ ប្រសិនបើអ្នកចង់កែប្រែឯកសារ ឯកសារនោះនឹងត្រូវបានចម្លងពីស្រទាប់បានតែអានខាងក្រោមទៅស្រទាប់អាន-សរសេរ។
កំណែដែលបានតែអាននៃឯកសារនឹងនៅតែមាន ប៉ុន្តែឥឡូវនេះត្រូវបានលាក់នៅក្រោមច្បាប់ចម្លង។ បរិមាណត្រូវបានប្រើដើម្បីរក្សាទុកទិន្នន័យ ដោយមិនគិតពីវដ្តជីវិតរបស់កុងតឺន័រ។ បរិមាណត្រូវបានចាប់ផ្តើមនៅពេលដែលកុងតឺន័រត្រូវបានបង្កើត។

តើរូបភាពភ្ជាប់ជាមួយកុងតឺន័រយ៉ាងដូចម្តេច?

រូបភាព។ - ធាតុសំខាន់សម្រាប់ធុងនីមួយៗ។ រូបភាពត្រូវបានបង្កើតឡើងពី Dockerfile ដែលត្រូវបានបន្ថែមទៅក្នុងគម្រោង ហើយជាសំណុំនៃប្រព័ន្ធឯកសារ (ស្រទាប់) ដែលដាក់នៅពីលើគ្នា និងដាក់ជាក្រុមជាមួយគ្នា អាចប្រើបានសម្រាប់តែការអានប៉ុណ្ណោះ។ ចំនួនស្រទាប់អតិបរមាគឺ 127 ។

បេះដូងនៃរូបភាពនីមួយៗគឺជារូបភាពមូលដ្ឋាន ដែលត្រូវបានបញ្ជាក់ដោយពាក្យបញ្ជា FROM - ចំណុចចូលនៅពេលបង្កើតរូបភាព Dockerfile ។ ស្រទាប់នីមួយៗគឺជាស្រទាប់ដែលបានអានតែប៉ុណ្ណោះ ហើយត្រូវបានតំណាងដោយពាក្យបញ្ជាតែមួយដែលកែប្រែប្រព័ន្ធឯកសារ ដែលសរសេរក្នុង Dockerfile ។
ដើម្បីបញ្ចូលគ្នានូវស្រទាប់ទាំងនេះទៅជារូបភាពតែមួយ Docker ប្រើប្រព័ន្ធឯកសារ Union ពហុស្រទាប់កម្រិតខ្ពស់ (AuFS ត្រូវបានបង្កើតឡើងនៅលើកំពូលនៃ UnionFS) ដែលអនុញ្ញាតឱ្យឯកសារ និងថតផ្សេងៗគ្នាពីស្រទាប់ឯកសារផ្សេងៗគ្នាដើម្បីត្រួតលើគ្នាដោយតម្លាភាព បង្កើតប្រព័ន្ធឯកសារដែលពាក់ព័ន្ធ។

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

Dockerfile អាចមានពាក្យបញ្ជាដូចជា៖

• ពី - ចំណុចចូលក្នុងការបង្កើតរូបភាព;
• អ្នកថែទាំ - ឈ្មោះរបស់ម្ចាស់រូបភាព;
• រត់ - ប្រតិបត្តិពាក្យបញ្ជាកំឡុងពេលដំឡើងរូបភាព;
• បន្ថែម - ការចម្លងឯកសារម៉ាស៊ីនទៅរូបភាពថ្មី ប្រសិនបើអ្នកបញ្ជាក់ឯកសារ URL នោះ Docker នឹងទាញយកវាទៅថតដែលបានបញ្ជាក់។
• ENV - អថេរបរិស្ថាន;
• CMD - ចាប់ផ្តើមការបង្កើតធុងថ្មីដោយផ្អែកលើរូបភាព;
• ENTRYPOINT - ពាក្យបញ្ជាត្រូវបានប្រតិបត្តិនៅពេលដែលកុងតឺន័រត្រូវបានចាប់ផ្តើម។
• WORKDIR គឺជាថតការងារសម្រាប់ប្រតិបត្តិពាក្យបញ្ជា CMD ។
• USER - កំណត់ UID សម្រាប់កុងតឺន័រដែលបានបង្កើតពីរូបភាព។
• កម្រិតសំឡេង - ដំឡើងថតម៉ាស៊ីនទៅកុងតឺន័រ។
• EXPOSE គឺជាសំណុំនៃច្រកដែលបានស្តាប់នៅក្នុងកុងតឺន័រ។

តើ UnionFS ដំណើរការយ៉ាងដូចម្តេច?

UnionFS - ប្រព័ន្ធឯកសារជង់សេវាកម្ម (FS) សម្រាប់លីនុច និង FreeBSD ។ FS នេះអនុវត្តយន្តការចម្លងលើការសរសេរ (Copy-On-Write, COW) ។ ឯកតាការងាររបស់ UnionFS គឺជាស្រទាប់មួយ ស្រទាប់នីមួយៗគួរតែត្រូវបានចាត់ទុកថាជាប្រព័ន្ធឯកសារពេញលេញដាច់ដោយឡែកដែលមានឋានានុក្រមថតពីឫសខ្លួនវា។ UnionFS បង្កើត union mount សម្រាប់ប្រព័ន្ធឯកសារផ្សេងទៀត ហើយអនុញ្ញាតឱ្យអ្នកបញ្ចូលឯកសារ និងថតដែលមានតម្លាភាពពីប្រព័ន្ធឯកសារផ្សេងៗគ្នា (ហៅថាសាខា) ទៅក្នុងប្រព័ន្ធឯកសារភ្ជាប់តែមួយ ប្រកបដោយតម្លាភាពចំពោះអ្នកប្រើប្រាស់។

មាតិកានៃថតដែលមានផ្លូវដូចគ្នានឹងត្រូវបានបង្ហាញរួមគ្នានៅក្នុងថតរួមបញ្ចូលគ្នាមួយ (ក្នុងចន្លោះឈ្មោះដូចគ្នា) នៃប្រព័ន្ធឯកសារលទ្ធផល។

UnionFS រួមបញ្ចូលគ្នានូវស្រទាប់ដោយផ្អែកលើគោលការណ៍ដូចខាងក្រោមៈ

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

Docker គឺជាបច្ចេកវិទ្យាទូទៅបំផុតសម្រាប់ការប្រើប្រាស់កុងតឺន័រក្នុងការងារកម្មវិធី។ វាបានក្លាយជាស្តង់ដារនៅក្នុងតំបន់នេះ ដោយបង្កើតនៅលើ cgroups និង namespaces ដែលផ្តល់ដោយខឺណែលលីនុច។

Docker អនុញ្ញាតឱ្យយើងដាក់ពង្រាយកម្មវិធីយ៉ាងឆាប់រហ័ស និងធ្វើឱ្យការប្រើប្រាស់ប្រព័ន្ធឯកសារល្អបំផុតដោយការចែករំលែកខឺណែល OS រវាងកុងតឺន័រទាំងអស់ ដោយដំណើរការជាដំណើរការប្រព័ន្ធប្រតិបត្តិការដាច់ដោយឡែក។

ប្រភព: www.habr.com