មានប្រព័ន្ធកុំព្យូទ័រចែកចាយ Apache Storm 2.0

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

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

ការរួមបញ្ចូលជាមួយប្រព័ន្ធដំណើរការជួរផ្សេងៗ និងបច្ចេកវិទ្យាមូលដ្ឋានទិន្នន័យត្រូវបានគាំទ្រ។ ស្ថាបត្យកម្ម Storm ពាក់ព័ន្ធនឹងការទទួល និងដំណើរការស្ទ្រីមទិន្នន័យដែលមិនមានរចនាសម្ព័ន្ធ ធ្វើបច្ចុប្បន្នភាពឥតឈប់ឈរ ដោយប្រើប្រព័ន្ធដំណើរការស្មុគស្មាញតាមអំពើចិត្ត ជាមួយនឹងសមត្ថភាពក្នុងការបែងចែករវាងដំណាក់កាលផ្សេងៗនៃការគណនា។ គម្រោងនេះត្រូវបានផ្ទេរទៅសហគមន៍ Apache បន្ទាប់ពី Twitter ទិញយក BackType ដែលជាក្រុមហ៊ុនដែលបង្កើតក្របខ័ណ្ឌដំបូង។ នៅក្នុងការអនុវត្តជាក់ស្តែង Storm ត្រូវបានប្រើក្នុង BackType ដើម្បីវិភាគការឆ្លុះបញ្ចាំងនៃព្រឹត្តិការណ៍នៅក្នុង microblogs ដោយប្រៀបធៀបនៅលើធ្វីតថ្មី និងតំណភ្ជាប់ដែលបានប្រើនៅក្នុងពួកវា (ឧទាហរណ៍ វាត្រូវបានវាយតម្លៃពីរបៀបដែលតំណភ្ជាប់ខាងក្រៅ ឬសេចក្តីប្រកាសដែលបានបោះពុម្ពនៅលើ Twitter ត្រូវបានផ្សាយឡើងវិញដោយអ្នកចូលរួមផ្សេងទៀត )

មុខងាររបស់ Storm ត្រូវបានប្រៀបធៀបទៅនឹងវេទិកា Hadoop ជាមួយនឹងភាពខុសគ្នាសំខាន់គឺថាទិន្នន័យមិនត្រូវបានរក្សាទុកនៅក្នុងឃ្លាំងទេ ប៉ុន្តែត្រូវបានបញ្ចូលទៅខាងក្រៅ និងដំណើរការក្នុងពេលវេលាជាក់ស្តែង។ Storm មិនមានស្រទាប់ផ្ទុកដែលភ្ជាប់មកជាមួយទេ ហើយសំណួរវិភាគចាប់ផ្តើមត្រូវបានអនុវត្តចំពោះទិន្នន័យចូលរហូតដល់វាត្រូវបានលុបចោល (ខណៈពេលដែល Hadoop ប្រើប្រាស់ការងារ MapReduce កំណត់ពេលវេលា Storm ប្រើគំនិតនៃការបន្តដំណើរការ "topologies") ។ ការប្រតិបត្តិរបស់ handlers អាចត្រូវបានចែកចាយនៅទូទាំង servers ជាច្រើន - Storm ធ្វើការស្របដោយស្វ័យប្រវត្តិជាមួយនឹង threads នៅលើ cluster nodes ផ្សេងៗគ្នា។

ប្រព័ន្ធនេះត្រូវបានសរសេរដំបូងនៅក្នុង Clojure ហើយដំណើរការនៅខាងក្នុងម៉ាស៊ីននិម្មិត JVM ។ មូលនិធិ Apache បានចាប់ផ្តើមគំនិតផ្តួចផ្តើមមួយដើម្បីធ្វើចំណាកស្រុក Storm ទៅកាន់ខឺណែលថ្មីដែលសរសេរជាភាសា Java ដែលជាលទ្ធផលដែលត្រូវបានស្នើឡើងក្នុងការចេញផ្សាយ Apache Storm 2.0 ។ សមាសធាតុជាមូលដ្ឋានទាំងអស់នៃវេទិកាត្រូវបានសរសេរឡើងវិញជាភាសាចាវ៉ា។ ការគាំទ្រសម្រាប់កម្មវិធីដោះស្រាយការសរសេរនៅក្នុង Clojure ត្រូវបានរក្សាទុក ប៉ុន្តែឥឡូវនេះត្រូវបានផ្តល់ជូនក្នុងទម្រង់នៃការចង។ Storm 2.0.0 ទាមទារ Java 8 ។ គំរូដំណើរការពហុខ្សែត្រូវបានរៀបចំឡើងវិញទាំងស្រុង ដែលអនុញ្ញាតឱ្យ សម្រេចបាន។ ការកើនឡើងគួរឱ្យកត់សម្គាល់នៅក្នុងការអនុវត្ត (សម្រាប់ topologies មួយចំនួនការពន្យារពេលត្រូវបានកាត់បន្ថយ 50-80%) ។

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

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

តំបន់នៃកម្មវិធីសម្រាប់ព្យុះ៖

• ដំណើរការស្ទ្រីមនៃទិន្នន័យថ្មី ឬការធ្វើបច្ចុប្បន្នភាពមូលដ្ឋានទិន្នន័យក្នុងពេលវេលាជាក់ស្តែង។
• Continuous Computing: Storm អាចដំណើរការសំណួរបន្ត និងដំណើរការស្ទ្រីមបន្ត ដោយផ្តល់លទ្ធផលដំណើរការដល់អតិថិជនក្នុងពេលវេលាជាក់ស្តែង។
• ការហៅតាមនីតិវិធីពីចម្ងាយដែលបានចែកចាយ (RPC)៖ ព្យុះអាចត្រូវបានប្រើដើម្បីផ្តល់នូវការប្រតិបត្តិស្របគ្នានៃសំណួរដែលពឹងផ្អែកលើធនធាន។ ការងារមួយ (“topology”) នៅក្នុង Storm គឺជាមុខងារមួយដែលចែកចាយនៅទូទាំងថ្នាំងដែលរង់ចាំសារមកដល់ ដែលចាំបាច់ត្រូវដំណើរការ។ បន្ទាប់ពីបានទទួលសារ មុខងារដំណើរការវានៅក្នុងបរិបទមូលដ្ឋាន ហើយត្រឡប់លទ្ធផល។ ឧទាហរណ៍នៃការប្រើប្រាស់ RPC ចែកចាយគឺដើម្បីដំណើរការសំណួរស្វែងរកស្របគ្នា ឬអនុវត្តប្រតិបត្តិការលើសំណុំធំមួយ។

លក្ខណៈពិសេសព្យុះ៖

• គំរូសរសេរកម្មវិធីដ៏សាមញ្ញដែលជួយសម្រួលដំណើរការទិន្នន័យក្នុងពេលវេលាជាក់ស្តែងយ៉ាងខ្លាំង។
• គាំទ្រសម្រាប់ភាសាសរសេរកម្មវិធីណាមួយ។ ម៉ូឌុលមានសម្រាប់ Java, Ruby និង Python ការសម្របខ្លួនសម្រាប់ភាសាផ្សេងទៀតគឺមានភាពងាយស្រួលដោយសារពិធីការទំនាក់ទំនងដ៏សាមញ្ញបំផុតដែលទាមទារកូដប្រហែល 100 ជួរដើម្បីគាំទ្រ។
• ការអត់ឱនកំហុស៖ ដើម្បីដំណើរការការងារដំណើរការទិន្នន័យ អ្នកត្រូវបង្កើតឯកសារ jar ជាមួយកូដ។ Storm នឹងចែកចាយឯកសារពាងនេះដោយឯករាជ្យនៅទូទាំងថ្នាំងចង្កោម ភ្ជាប់ឧបករណ៍ដោះស្រាយដែលភ្ជាប់ជាមួយវា និងរៀបចំការត្រួតពិនិត្យ។ នៅពេលដែលការងារបានបញ្ចប់ លេខកូដនឹងត្រូវបានបិទដោយស្វ័យប្រវត្តិនៅលើថ្នាំងទាំងអស់;
• លទ្ធភាពធ្វើមាត្រដ្ឋានផ្ដេក។ ការគណនាទាំងអស់ត្រូវបានអនុវត្តក្នុងរបៀបប៉ារ៉ាឡែល នៅពេលដែលបន្ទុកកើនឡើង វាគ្រប់គ្រាន់ដើម្បីភ្ជាប់ថ្នាំងថ្មីទៅនឹងចង្កោម។
• ភាពជឿជាក់។ Storm ធានាថារាល់សារចូលត្រូវបានដំណើរការយ៉ាងពេញលេញយ៉ាងហោចណាស់ម្តង។ សារនឹងត្រូវបានដំណើរការតែម្តងប៉ុណ្ណោះ ប្រសិនបើមិនមានកំហុសនៅពេលឆ្លងកាត់អ្នកដោះស្រាយទាំងអស់ ប្រសិនបើមានបញ្ហាកើតឡើង នោះការព្យាយាមដំណើរការដែលមិនជោគជ័យនឹងត្រូវធ្វើម្តងទៀត។
• ល្បឿន។ កូដរបស់ Storm ត្រូវបានសរសេរដោយមានដំណើរការខ្ពស់ក្នុងចិត្ត និងប្រើប្រាស់ប្រព័ន្ធសម្រាប់ការផ្ញើសារអសមកាលលឿន ZeroMQ.

ប្រភព: opennet.ru