ការអនុវត្តល្អបំផុត Kubernetes ។ ការបង្កើតធុងតូច

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

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

លើសពីនេះ រូបភាពភាគច្រើននៅក្នុង Docker ប្រើ Debian ឬ Ubuntu សម្រាប់រូបភាពមូលដ្ឋាន ហើយខណៈពេលដែលវាផ្តល់នូវភាពឆបគ្នាដ៏ល្អ និងការប្ដូរតាមបំណងដ៏ងាយស្រួល (ឯកសារ Docker ប្រើតែពីរបន្ទាត់នៃកូដ) រូបភាពមូលដ្ឋានអាចបន្ថែមបន្ទុកបន្ថែមរាប់រយមេកាបៃទៅក្នុងកុងតឺន័ររបស់អ្នក។ ឧទាហរណ៍ ឯកសារ node.js សាមញ្ញសម្រាប់កម្មវិធី Go "hello-world" គឺប្រហែល 700 មេកាបៃ ខណៈដែលកម្មវិធីពិតរបស់អ្នកមានទំហំត្រឹមតែពីរបីមេហ្គាបៃប៉ុណ្ណោះ។

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

ទីមួយគឺការប្រើប្រាស់រូបភាពមូលដ្ឋានតូច ទីពីរគឺការប្រើប្រាស់គំរូ Builder ។ ការប្រើរូបភាពមូលដ្ឋានតូចជាងគឺប្រហែលជាវិធីងាយស្រួលបំផុតដើម្បីកាត់បន្ថយទំហំធុងរបស់អ្នក។ ភាគច្រើនទំនងជាភាសា ឬជង់ដែលអ្នកកំពុងប្រើផ្តល់នូវរូបភាពកម្មវិធីដើមដែលតូចជាងរូបភាពលំនាំដើមច្រើន។ តោះមើលកុងតឺន័រ node.js របស់យើង។

តាមលំនាំដើមនៅក្នុង Docker ទំហំរូបភាពមូលដ្ឋាននៃ node:8 គឺ 670 MB ហើយថ្នាំង៖ ទំហំរូបភាព 8-alpine គឺត្រឹមតែ 65 MB ពោលគឺតូចជាង 10 ដង។ ដោយប្រើរូបភាពមូលដ្ឋាន Alpine តូចជាងនេះ អ្នកនឹងកាត់បន្ថយទំហំធុងរបស់អ្នក។ Alpine គឺជាការចែកចាយលីនុចតូច និងស្រាល ដែលមានប្រជាប្រិយភាពខ្លាំងក្នុងចំណោមអ្នកប្រើប្រាស់ Docker ព្រោះវាអាចប្រើបានជាមួយកម្មវិធីជាច្រើន ខណៈពេលដែលរក្សាធុងតូច។ មិនដូចរូបភាព Docker "node" ស្តង់ដារ "node:alpine" លុបឯកសារសេវាកម្ម និងកម្មវិធីជាច្រើន ដោយបន្សល់ទុកតែឯកសារដែលគ្រប់គ្រាន់ដើម្បីដំណើរការកម្មវិធីរបស់អ្នក។

ដើម្បីផ្លាស់ទីទៅរូបភាពមូលដ្ឋានតូចជាង គ្រាន់តែធ្វើបច្ចុប្បន្នភាព Dockerfile ដើម្បីចាប់ផ្តើមធ្វើការជាមួយរូបភាពមូលដ្ឋានថ្មី៖

ឥឡូវនេះ មិនដូចរូបភាព onbuild ចាស់ទេ អ្នកត្រូវចម្លងកូដរបស់អ្នកទៅក្នុងកុងតឺន័រ ហើយដំឡើងភាពអាស្រ័យណាមួយ។ នៅក្នុង Dockerfile ថ្មី កុងតឺន័រចាប់ផ្តើមដោយ node:alpine image បន្ទាប់មកបង្កើត directory សម្រាប់ code ដំឡើង dependencies ដោយប្រើ NPM package manager ហើយចុងក្រោយដំណើរការ server.js។

ការអាប់ដេតនេះនាំឱ្យធុងដែលមានទំហំតូចជាង 10 ដង។ ប្រសិនបើភាសាសរសេរកម្មវិធី ឬជង់របស់អ្នកមិនមានមុខងារកាត់បន្ថយរូបភាពមូលដ្ឋាន សូមប្រើ Alpine Linux ។ វាក៏នឹងផ្តល់នូវសមត្ថភាពក្នុងការគ្រប់គ្រងមាតិការបស់ធុងយ៉ាងពេញលេញផងដែរ។ ការប្រើរូបភាពមូលដ្ឋានតូចគឺជាវិធីដ៏ល្អមួយដើម្បីបង្កើតធុងតូចបានយ៉ាងឆាប់រហ័ស។ ប៉ុន្តែសូម្បីតែការកាត់បន្ថយកាន់តែច្រើនអាចត្រូវបានសម្រេចដោយប្រើ Builder Pattern ។

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

កូដត្រូវបានបង្កើតនៅក្នុងកុងតឺន័រដំបូង និងចងក្រង។ បន្ទាប់មក កូដដែលបានចងក្រងត្រូវបានខ្ចប់ចូលទៅក្នុងកុងតឺន័រចុងក្រោយ ដោយគ្មានកម្មវិធីចងក្រង និងឧបករណ៍ដែលត្រូវការដើម្បីចងក្រងកូដនោះ។ តោះដំណើរការកម្មវិធី Go តាមរយៈដំណើរការនេះ។ ដំបូង យើងនឹងផ្លាស់ទីពីរូបភាព onbuild ទៅ Alpine Linux ។

នៅក្នុង Dockerfile ថ្មី កុងតឺន័រចាប់ផ្តើមដោយរូបភាព golang:alpine ។ បន្ទាប់​មក​វា​បង្កើត​ថត​សម្រាប់​កូដ ចម្លង​វា​ទៅ​ក្នុង​កូដ​ប្រភព បង្កើត​កូដ​ប្រភព​នោះ និង​ដំណើរការ​កម្មវិធី។ កុងតឺន័រនេះមានទំហំតូចជាងកុងតឺន័រ onbuild ប៉ុន្តែវានៅតែមានឧបករណ៍ចងក្រង និងឧបករណ៍ Go ផ្សេងទៀតដែលយើងពិតជាមិនត្រូវការ។ ដូច្នេះ​យើង​គ្រាន់តែ​ស្រង់​កម្មវិធី​ដែល​ចងក្រង​មក​ដាក់​ក្នុង​កុងតឺន័រ​របស់​វា​ប៉ុណ្ណោះ។

អ្នកអាចសម្គាល់ឃើញអ្វីមួយចម្លែកនៅក្នុងឯកសារ Docker នេះ៖ វាមានពីរបន្ទាត់ FROM ។ ផ្នែក 4 ជួរដំបូងមើលទៅដូចគ្នាទៅនឹង Dockerfile មុន លើកលែងតែវាប្រើពាក្យគន្លឹះ AS ដើម្បីដាក់ឈ្មោះដំណាក់កាលនេះ។ ផ្នែកបន្ទាប់មានបន្ទាត់ FROM ថ្មី ដើម្បីចាប់ផ្តើមរូបភាពថ្មី ដែលជំនួសឱ្យរូបភាព golang:alpine យើងនឹងប្រើ Raw alpine ជារូបភាពមូលដ្ឋាន។

Raw Alpine Linux មិន​មាន​វិញ្ញាបនបត្រ SSL ណា​មួយ​បាន​ដំឡើង​ទេ ដែល​នឹង​ធ្វើ​ឱ្យ​ការ​ហៅ API ភាគច្រើន​តាម HTTPS បរាជ័យ ដូច្នេះ​សូម​ដំឡើង​វិញ្ញាបនបត្រ CA ជា root ខ្លះ។

ឥឡូវនេះមកផ្នែករីករាយ៖ ដើម្បីចម្លងកូដដែលបានចងក្រងពីកុងតឺន័រទីមួយទៅធុងទីពីរ អ្នកអាចប្រើពាក្យបញ្ជាចម្លងដែលមានទីតាំងនៅបន្ទាត់ទី 5 នៃផ្នែកទីពីរ។ វានឹងចម្លងឯកសារកម្មវិធីតែមួយប៉ុណ្ណោះ ហើយនឹងមិនប៉ះពាល់ដល់ឧបករណ៍ប្រើប្រាស់ Go ទេ។ ឯកសារ Docker ពហុដំណាក់កាលថ្មីនឹងមានរូបភាពកុងតឺន័រដែលមានទំហំត្រឹមតែ 12 មេកាបៃប៉ុណ្ណោះ បើប្រៀបធៀបទៅនឹងរូបភាពកុងតឺន័រដើមដែលមាន 700 មេកាបៃ ដែលជាភាពខុសគ្នាខ្លាំង!
ដូច្នេះការប្រើរូបភាពមូលដ្ឋានតូច និង Builder Pattern គឺជាវិធីដ៏ល្អក្នុងការបង្កើតធុងតូចជាងច្រើនដោយមិនចាំបាច់ធ្វើការច្រើន។
វាអាចទៅរួចដែលអាស្រ័យលើជង់កម្មវិធី មានវិធីបន្ថែមដើម្បីកាត់បន្ថយទំហំរូបភាព និងធុង ប៉ុន្តែតើធុងតូចពិតជាមានអត្ថប្រយោជន៍ដែលអាចវាស់វែងបានដែរឬទេ? សូមក្រឡេកមើលតំបន់ពីរដែលធុងតូចមានប្រសិទ្ធភាពខ្លាំង - ការអនុវត្ត និងសុវត្ថិភាព។

ដើម្បីវាយតម្លៃការកើនឡើងនៃការអនុវត្ត សូមពិចារណាពីរយៈពេលនៃដំណើរការបង្កើតកុងតឺន័រ បញ្ចូលវាទៅក្នុងបញ្ជីឈ្មោះ (រុញ) ហើយបន្ទាប់មកយកវាពីទីនោះ (ទាញ)។ អ្នក​អាច​មើល​ឃើញ​ថា​កុងតឺន័រ​តូច​មាន​អត្ថប្រយោជន៍​ខុស​ប្លែក​ពី​ធុង​ធំ។

Docker នឹង​រក្សា​ទុក​ស្រទាប់ ដូច្នេះ​ការ​បង្កើត​ជា​បន្តបន្ទាប់​នឹង​មាន​ល្បឿន​លឿន​ណាស់។ ទោះយ៉ាងណាក៏ដោយ ប្រព័ន្ធ CI ជាច្រើនដែលប្រើសម្រាប់សាងសង់ និងសាកល្បងធុងមិនផ្ទុកស្រទាប់ ដូច្នេះមានការសន្សំពេលវេលាដ៏សំខាន់។ ដូចដែលអ្នកអាចឃើញពេលវេលាសាងសង់ធុងធំមួយអាស្រ័យលើថាមពលនៃម៉ាស៊ីនរបស់អ្នកគឺពី 34 ទៅ 54 វិនាទីហើយនៅពេលប្រើកុងតឺន័រកាត់បន្ថយដោយប្រើគំរូអ្នកសាងសង់ - ពី 23 ទៅ 28 វិនាទី។ សម្រាប់ប្រតិបត្តិការនៃប្រភេទនេះការកើនឡើងផលិតភាពនឹងមាន 40-50% ។ ដូច្នេះគ្រាន់តែគិតថាតើអ្នកបង្កើត និងសាកល្បងកូដរបស់អ្នកប៉ុន្មានដង។

បន្ទាប់ពីកុងតឺន័រត្រូវបានសាងសង់ អ្នកត្រូវរុញរូបភាពរបស់វា (រូបភាពកុងតឺន័ររុញ) ទៅក្នុងបញ្ជីឈ្មោះកុងតឺន័រ ដូច្នេះអ្នកអាចប្រើវានៅក្នុងចង្កោម Kubernetes របស់អ្នក។ ខ្ញុំសូមណែនាំឱ្យប្រើ Google Container Registry ។

ជាមួយនឹង Google Container Registry (GCR) អ្នកគ្រាន់តែចំណាយលើការផ្ទុកឆៅ និងបណ្តាញប៉ុណ្ណោះ ហើយមិនមានថ្លៃគ្រប់គ្រងកុងតឺន័របន្ថែមទេ។ វាជាឯកជន សុវត្ថិភាព និងលឿនណាស់។ GCR ប្រើល្បិចជាច្រើនដើម្បីបង្កើនល្បឿនប្រតិបត្តិការទាញ។ ដូចដែលអ្នកអាចឃើញ ការបញ្ចូល Docker Container Image container ដោយប្រើ go:onbuild នឹងចំណាយពេលពី 15 ទៅ 48 វិនាទី អាស្រ័យលើដំណើរការរបស់កុំព្យូទ័រ ហើយប្រតិបត្តិការដូចគ្នាជាមួយកុងតឺន័រតូចជាងនឹងចំណាយពេលពី 14 ទៅ 16 វិនាទី ហើយសម្រាប់ម៉ាស៊ីនដែលមិនសូវមានផលិតភាព អត្ថប្រយោជន៍ក្នុងល្បឿនប្រតិបត្តិការកើនឡើង 3 ដង។ សម្រាប់ម៉ាស៊ីនធំ ពេលវេលាគឺប្រហែលដូចគ្នា ដោយសារ GCR ប្រើឃ្លាំងសម្ងាត់សកលសម្រាប់មូលដ្ឋានទិន្នន័យរួមនៃរូបភាព មានន័យថាអ្នកមិនចាំបាច់ផ្ទុកពួកវាទាល់តែសោះ។ នៅក្នុងកុំព្យូទ័រដែលមានថាមពលទាប ស៊ីភីយូគឺជាឧបសគ្គ ដូច្នេះអត្ថប្រយោជន៍នៃការប្រើប្រាស់ធុងតូចគឺធំជាងនៅទីនេះ។

ប្រសិនបើអ្នកកំពុងប្រើ GCR ខ្ញុំសូមណែនាំឱ្យប្រើ Google Container Builder (GCB) ជាផ្នែកនៃប្រព័ន្ធសាងសង់របស់អ្នក។

ដូចដែលអ្នកអាចឃើញការប្រើប្រាស់របស់វាអនុញ្ញាតឱ្យអ្នកសម្រេចបាននូវលទ្ធផលល្អប្រសើរជាងមុនក្នុងការកាត់បន្ថយរយៈពេលនៃប្រតិបត្តិការ Build + Push ជាងសូម្បីតែម៉ាស៊ីនដែលមានផលិតភាព - ក្នុងករណីនេះដំណើរការនៃការសាងសង់និងបញ្ជូនធុងទៅម៉ាស៊ីនគឺលឿនជាងស្ទើរតែ 2 ដង។ លើសពីនេះ អ្នកទទួលបាន 120 នាទីសាងសង់ដោយឥតគិតថ្លៃជារៀងរាល់ថ្ងៃ ដែលគ្របដណ្តប់តម្រូវការអគារកុងតឺន័ររបស់អ្នកក្នុងករណីភាគច្រើន។

បន្ទាប់​មក​មក​នូវ​មាត្រដ្ឋាន​ប្រតិបត្តិការ​ដ៏​សំខាន់​បំផុត – ល្បឿន​នៃ​ការ​ទាញ​យក ឬ​ទាញ​យក​ធុង។ ហើយប្រសិនបើអ្នកមិនខ្វល់ច្រើនអំពីពេលវេលាដែលចំណាយលើប្រតិបត្តិការរុញទេ នោះរយៈពេលនៃដំណើរការទាញមានផលប៉ះពាល់យ៉ាងធ្ងន់ធ្ងរដល់ដំណើរការប្រព័ន្ធទាំងមូល។ ចូរនិយាយថាអ្នកមានចង្កោមនៃថ្នាំងបី ហើយមួយក្នុងចំណោមពួកវាបរាជ័យ។ ប្រសិនបើអ្នកកំពុងប្រើប្រព័ន្ធគ្រប់គ្រងដូចជា Google Kubernetes Engine វានឹងជំនួសថ្នាំងដែលងាប់ដោយស្វ័យប្រវត្តជាមួយថ្មី។ ទោះយ៉ាងណាក៏ដោយ ថ្នាំងថ្មីនេះនឹងទទេទាំងស្រុង ហើយអ្នកនឹងត្រូវអូសកុងតឺន័រទាំងអស់របស់អ្នកចូលទៅក្នុងវាដើម្បីឱ្យវាចាប់ផ្តើមដំណើរការ។ ប្រសិនបើប្រតិបត្តិការទាញចំណាយពេលយូរគ្រប់គ្រាន់ ចង្កោមរបស់អ្នកនឹងដំណើរការនៅកម្រិតទាបពេញមួយពេល។

មានករណីជាច្រើនដែលវាអាចកើតឡើង៖ ការបន្ថែមថ្នាំងថ្មីទៅចង្កោម ការធ្វើឱ្យប្រសើរថ្នាំង ឬសូម្បីតែការប្តូរទៅកុងតឺន័រថ្មីសម្រាប់ការដាក់ពង្រាយ។ ដូច្នេះ ការ​កាត់​បន្ថយ​ពេល​វេលា​ទាញ​យក​បាន​ក្លាយ​ជា​កត្តា​សំខាន់។ វាមិនអាចប្រកែកបានទេថាធុងតូចមួយទាញយកលឿនជាងធុងធំ។ ប្រសិនបើអ្នកកំពុងដំណើរការកុងតឺន័រច្រើននៅក្នុងចង្កោម Kubernetes ការសន្សំពេលវេលាអាចមានសារៈសំខាន់។

សូមក្រឡេកមើលការប្រៀបធៀបនេះ៖ ប្រតិបត្តិការទាញលើធុងតូចៗចំណាយពេលតិចជាង ៤-៩ ដង អាស្រ័យលើថាមពលរបស់ម៉ាស៊ីន ជាងប្រតិបត្តិការដូចគ្នាដោយប្រើ go:onbuild ។ ការប្រើប្រាស់រូបភាពមូលដ្ឋានកុងតឺន័រតូចដែលបានចែករំលែក បង្កើនល្បឿនយ៉ាងសំខាន់នូវពេលវេលា និងល្បឿនដែលថ្នាំង Kubernetes ថ្មីអាចត្រូវបានដាក់ឱ្យប្រើប្រាស់ និងមកលើអ៊ីនធឺណិត។

សូមក្រឡេកមើលបញ្ហាសន្តិសុខ។ ធុងតូចត្រូវបានចាត់ទុកថាមានសុវត្ថិភាពជាងធុងធំជាង ដោយសារពួកវាមានផ្ទៃវាយប្រហារតូចជាង។ តើវាពិតជាមែនទេ? លក្ខណៈពិសេសដ៏មានប្រយោជន៍បំផុតមួយនៃ Google Container Registry គឺសមត្ថភាពក្នុងការស្កេនធុងផ្ទុករបស់អ្នកដោយស្វ័យប្រវត្តិសម្រាប់ភាពងាយរងគ្រោះ។ កាលពីប៉ុន្មានខែមុន ខ្ញុំបានបង្កើតទាំង onbuild និង multistage containers ដូច្នេះសូមមើលថាតើមានភាពងាយរងគ្រោះណាមួយនៅទីនោះ។

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

ការយកវាចេញគឺច្បាស់ណាស់៖ បង្កើតធុងតូចៗ ព្រោះវាផ្តល់នូវការអនុវត្តជាក់ស្តែង និងអត្ថប្រយោជន៍សុវត្ថិភាពដល់ប្រព័ន្ធរបស់អ្នក។

ការអនុវត្តល្អបំផុត Kubernetes ។ អង្គការ Kubernetes ដែលមានលំហឈ្មោះ

ការផ្សាយពាណិជ្ជកម្មមួយចំនួន🙂

សូមអរគុណចំពោះការស្នាក់នៅជាមួយពួកយើង។ តើអ្នកចូលចិត្តអត្ថបទរបស់យើងទេ? ចង់មើលខ្លឹមសារគួរឱ្យចាប់អារម្មណ៍បន្ថែមទៀតទេ? គាំទ្រយើងដោយការបញ្ជាទិញឬណែនាំដល់មិត្តភក្តិ, cloud VPS សម្រាប់អ្នកអភិវឌ្ឍន៍ចាប់ពី $4.99, analogue តែមួយគត់នៃម៉ាស៊ីនមេកម្រិតធាតុ ដែលត្រូវបានបង្កើតឡើងដោយពួកយើងសម្រាប់អ្នក៖ ការពិតទាំងមូលអំពី VPS (KVM) E5-2697 v3 (6 Cores) 10GB DDR4 480GB SSD 1Gbps ចាប់ពី $19 ឬរបៀបចែករំលែកម៉ាស៊ីនមេ? (អាចប្រើបានជាមួយ RAID1 និង RAID10 រហូតដល់ 24 cores និងរហូតដល់ 40GB DDR4)។

Dell R730xd 2x ថោកជាងនៅក្នុងមជ្ឈមណ្ឌលទិន្នន័យ Equinix Tier IV នៅទីក្រុង Amsterdam? នៅទីនេះ 2 x Intel TetraDeca-Core Xeon 2x E5-2697v3 2.6GHz 14C 64GB DDR4 4x960GB SSD 1Gbps 100 TV ចាប់ពី $199 នៅប្រទេសហូឡង់! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - ចាប់ពី $99! អាន​អំពី របៀបបង្កើតក្រុមហ៊ុនហេដ្ឋារចនាសម្ព័ន្ធ ថ្នាក់ជាមួយនឹងការប្រើប្រាស់ម៉ាស៊ីនមេ Dell R730xd E5-2650 v4 ដែលមានតម្លៃ 9000 អឺរ៉ូសម្រាប់មួយកាក់?

ប្រភព: www.habr.com