RoadRunner: PHP មិនត្រូវបានបង្កើតឡើងដើម្បីស្លាប់ ឬ Golang ដើម្បីជួយសង្គ្រោះនោះទេ។

ហេហេ! យើងសកម្មនៅ Badoo ធ្វើការលើការអនុវត្ត PHPដោយសារយើងមានប្រព័ន្ធធំល្មមនៅក្នុងភាសានេះហើយបញ្ហានៃការអនុវត្តគឺជាបញ្ហាសន្សំប្រាក់។ កាលពីជាងដប់ឆ្នាំមុន យើងបានបង្កើត PHP-FPM សម្រាប់រឿងនេះ ដែលដំបូងឡើយជាសំណុំនៃបំណះសម្រាប់ PHP ហើយក្រោយមកបានបញ្ចូលការចែកចាយជាផ្លូវការ។

ក្នុងប៉ុន្មានឆ្នាំថ្មីៗនេះ PHP មានការរីកចម្រើនយ៉ាងខ្លាំង៖ អ្នកប្រមូលសំរាមមានភាពប្រសើរឡើង កម្រិតនៃស្ថេរភាពបានកើនឡើង - ថ្ងៃនេះអ្នកអាចសរសេរដេមិន និងស្គ្រីបដែលមានអាយុកាលយូរនៅក្នុង PHP ដោយគ្មានបញ្ហាអ្វីទាំងអស់។ នេះអនុញ្ញាតឱ្យ Spiral Scout បន្តទៅមុខទៀត៖ RoadRunner មិនដូច PHP-FPM ទេ មិនសម្អាតអង្គចងចាំរវាងសំណើដែលផ្តល់អត្ថប្រយោជន៍បន្ថែម (ទោះបីជាវិធីសាស្រ្តនេះធ្វើឱ្យស្មុគស្មាញដល់ដំណើរការអភិវឌ្ឍន៍ក៏ដោយ)។ បច្ចុប្បន្នយើងកំពុងពិសោធជាមួយឧបករណ៍នេះ ប៉ុន្តែយើងមិនទាន់មានលទ្ធផលណាមួយដែលត្រូវចែករំលែកនៅឡើយទេ។ ដើម្បីធ្វើឱ្យការរង់ចាំពួកគេកាន់តែសប្បាយរីករាយ, យើងបោះពុម្ពផ្សាយការបកប្រែនៃសេចក្តីប្រកាស RoadRunner ពី Spiral Scout ។

វិធីសាស្រ្តពីអត្ថបទគឺនៅជិតយើង៖ នៅពេលដោះស្រាយបញ្ហារបស់យើង យើងក៏ប្រើជាញឹកញាប់បំផុតនៃ PHP និង Go ដោយទទួលបានអត្ថប្រយោជន៍នៃភាសាទាំងពីរ ហើយមិនបោះបង់ចោលមួយនៅក្នុងការពេញចិត្តនៃភាសាផ្សេងទៀត។

សូមរីករាយជាមួយ!

ក្នុងរយៈពេលដប់ឆ្នាំចុងក្រោយនេះ យើងបានបង្កើតកម្មវិធីសម្រាប់ក្រុមហ៊ុនពីបញ្ជី សំណាងទី 500និងសម្រាប់អាជីវកម្មដែលមានអ្នកប្រើប្រាស់មិនលើសពី 500 នាក់។ គ្រប់ពេលវេលានេះ វិស្វកររបស់យើងបាននិងកំពុងបង្កើតកម្មវិធីខាងក្រោយជាចម្បងនៅក្នុង PHP ។ ប៉ុន្តែកាលពី XNUMX ឆ្នាំមុន អ្វីមួយបានជះឥទ្ធិពលយ៉ាងធំធេងមិនត្រឹមតែលើដំណើរការនៃផលិតផលរបស់យើងប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងលើសមត្ថភាពធ្វើមាត្រដ្ឋានរបស់វាផងដែរ - យើងបានណែនាំ Golang (Go) ទៅក្នុងជង់បច្ចេកវិទ្យារបស់យើង។

ស្ទើរតែភ្លាមៗនោះ យើងបានរកឃើញថា Go បានអនុញ្ញាតឱ្យយើងបង្កើតកម្មវិធីធំជាងមុន ជាមួយនឹងការកែលម្អដំណើរការរហូតដល់ 40 ដង។ ជាមួយវា យើងអាចពង្រីកផលិតផល PHP ដែលមានស្រាប់របស់យើង ដោយធ្វើអោយវាប្រសើរឡើងដោយការរួមបញ្ចូលគ្នានូវអត្ថប្រយោជន៍នៃភាសាទាំងពីរ។

យើងនឹងប្រាប់អ្នកពីរបៀបដែលការរួមបញ្ចូលគ្នានៃ Go និង PHP ជួយដោះស្រាយបញ្ហាអភិវឌ្ឍន៍ពិតប្រាកដ និងរបៀបដែលវាបានប្រែក្លាយទៅជាឧបករណ៍សម្រាប់ពួកយើង ដែលអាចកម្ចាត់បញ្ហាមួយចំនួនដែលទាក់ទងនឹង ម៉ូដែល PHP ស្លាប់.

បរិយាកាសអភិវឌ្ឍន៍ PHP ប្រចាំថ្ងៃរបស់អ្នក។

មុនពេលយើងនិយាយអំពីរបៀបដែលអ្នកអាចប្រើ Go ដើម្បីធ្វើឱ្យគំរូ PHP ស្លាប់ឡើងវិញ សូមក្រឡេកមើលបរិស្ថានអភិវឌ្ឍន៍ PHP លំនាំដើមរបស់អ្នក។

ក្នុងករណីភាគច្រើន អ្នកដំណើរការកម្មវិធីរបស់អ្នកដោយប្រើការរួមបញ្ចូលគ្នានៃម៉ាស៊ីនមេបណ្តាញ nginx និងម៉ាស៊ីនមេ PHP-FPM ។ អតីតបម្រើឯកសារឋិតិវន្ត និងបញ្ជូនបន្តសំណើជាក់លាក់ទៅ PHP-FPM ខណៈពេលដែល PHP-FPM ខ្លួនវាប្រតិបត្តិកូដ PHP ។ អ្នកប្រហែលជាកំពុងប្រើការរួមបញ្ចូលគ្នាដ៏ពេញនិយមតិចនៃ Apache និង mod_php ។ ប៉ុន្តែទោះបីជាវាដំណើរការខុសគ្នាបន្តិចបន្តួចក៏ដោយក៏គោលការណ៍គឺដូចគ្នា។

តោះមើលពីរបៀបដែល PHP-FPM ប្រតិបត្តិកូដកម្មវិធី។ នៅពេលសំណើចូលមក PHP-FPM ចាប់ផ្តើមដំណើរការកូន PHP ហើយឆ្លងកាត់ព័ត៌មានលម្អិតនៃសំណើជាផ្នែកនៃស្ថានភាពរបស់វា (_GET, _POST, _SERVER ។ល។)។

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

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

គុណវិបត្តិ និងអសមត្ថភាពនៃបរិស្ថាន PHP ធម្មតា។

ប្រសិនបើអ្នកជាអ្នកបង្កើត PHP ដែលមានជំនាញវិជ្ជាជីវៈ នោះអ្នកដឹងពីកន្លែងដែលត្រូវចាប់ផ្តើមគម្រោងថ្មី - ជាមួយនឹងជម្រើសនៃក្របខ័ណ្ឌមួយ។ វាមានបណ្ណាល័យចាក់ថ្នាំអាស្រ័យ ORMs ការបកប្រែ និងគំរូ។ ហើយជាការពិតណាស់ រាល់ការបញ្ចូលរបស់អ្នកប្រើប្រាស់អាចងាយស្រួលដាក់ចូលទៅក្នុងវត្ថុតែមួយ (Symfony/HttpFoundation ឬ PSR-7)។ ស៊ុមគឺឡូយ!

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

វិស្វករ PHP បានស្វែងរកវិធីដោះស្រាយបញ្ហានេះអស់ជាច្រើនឆ្នាំ ដោយប្រើប្រាស់បច្ចេកទេសផ្ទុកខ្ជិលដ៏ឆ្លាតវៃ មីក្រូហ្វ្រេម បណ្ណាល័យដែលធ្វើឱ្យប្រសើរឡើង ឃ្លាំងសម្ងាត់។ល។ ប៉ុន្តែនៅទីបញ្ចប់ អ្នកនៅតែត្រូវកំណត់កម្មវិធីទាំងមូលឡើងវិញ ហើយចាប់ផ្តើមម្តងហើយម្តងទៀត។ . (កំណត់សម្គាល់របស់អ្នកបកប្រែ៖ បញ្ហានេះនឹងត្រូវបានដោះស្រាយដោយផ្នែកជាមួយនឹងការមកដល់នៃ ផ្ទុកជាមុន ក្នុង PHP 7.4)

តើ PHP ជាមួយ Go អាចរស់បានច្រើនជាងសំណើមួយទេ?

វាអាចទៅរួចក្នុងការសរសេរស្គ្រីប PHP ដែលមានរយៈពេលវែងជាងពីរបីនាទី (រហូតដល់ម៉ោង ឬច្រើនថ្ងៃ)៖ ឧទាហរណ៍ កិច្ចការ cron, CSV parser, អ្នកបំបែកជួរ។ ពួកគេទាំងអស់ធ្វើការតាមសេណារីយ៉ូដូចគ្នា៖ ពួកគេទាញយកភារកិច្ច ប្រតិបត្តិវា ហើយរង់ចាំកិច្ចការបន្ទាប់។ កូដស្ថិតនៅក្នុងអង្គចងចាំគ្រប់ពេលវេលា ដោយរក្សាទុកមីលីវិនាទីដ៏មានតម្លៃ ដោយសារមានជំហានបន្ថែមជាច្រើនដែលទាមទារដើម្បីផ្ទុកក្របខ័ណ្ឌ និងកម្មវិធី។

ប៉ុន្តែ​ការ​បង្កើត​ស្គ្រីប​ដែល​មាន​អាយុ​វែង​មិន​មែន​ជា​ការ​ងាយ​ស្រួល​នោះ​ទេ។ កំហុសណាមួយបានសម្លាប់ដំណើរការទាំងស្រុង ការធ្វើរោគវិនិច្ឆ័យការលេចធ្លាយអង្គចងចាំគឺជាការខឹងសម្បារ ហើយការកែកំហុស F5 គឺមិនអាចធ្វើទៅបានទៀតទេ។

ស្ថានភាពបានប្រសើរឡើងជាមួយនឹងការចេញផ្សាយ PHP 7៖ អ្នកប្រមូលសំរាមដែលអាចទុកចិត្តបានបានបង្ហាញខ្លួន វាកាន់តែងាយស្រួលក្នុងការដោះស្រាយកំហុស ហើយផ្នែកបន្ថែមខឺណែលឥឡូវនេះមានភស្តុតាងលេចធ្លាយ។ ពិតហើយ វិស្វករនៅតែត្រូវប្រុងប្រយ័ត្នជាមួយនឹងការចងចាំ ហើយត្រូវដឹងពីបញ្ហារដ្ឋនៅក្នុងកូដ (តើមានភាសាដែលអាចមិនអើពើនឹងរឿងទាំងនេះទេ?) ទោះយ៉ាងណាក៏ដោយ PHP 7 មានការភ្ញាក់ផ្អើលតិចជាងនៅក្នុងហាងសម្រាប់យើង។

តើវាអាចទៅរួចទេក្នុងការយកគំរូនៃការធ្វើការជាមួយស្គ្រីប PHP ដែលមានអាយុកាលយូរមក សម្របវាទៅនឹងកិច្ចការតូចតាចជាច្រើនទៀត ដូចជាការដំណើរការសំណើ HTTP ហើយដោយហេតុនេះ កម្ចាត់តម្រូវការក្នុងការផ្ទុកអ្វីៗទាំងអស់ពីទទេជាមួយនឹងសំណើនីមួយៗ?

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

យើងដឹងថាយើងអាចសរសេរ web server ជា PHP សុទ្ធ (PHP-PM) ឬប្រើ C extension (Swoole)។ ហើយទោះបីជាវិធីសាស្រ្តនីមួយៗមានគុណសម្បត្តិរបស់វាក៏ដោយ ជម្រើសទាំងពីរមិនសមនឹងយើងទេ - យើងចង់បានអ្វីបន្ថែមទៀត។ យើងត្រូវការច្រើនជាងម៉ាស៊ីនមេគេហទំព័រ - យើងរំពឹងថានឹងទទួលបានដំណោះស្រាយដែលអាចជួយសង្រ្គោះយើងពីបញ្ហាដែលទាក់ទងនឹង "ការចាប់ផ្តើមរឹង" នៅក្នុង PHP ដែលក្នុងពេលតែមួយអាចសម្របខ្លួនបានយ៉ាងងាយស្រួល និងពង្រីកសម្រាប់កម្មវិធីជាក់លាក់។ នោះគឺយើងត្រូវការម៉ាស៊ីនមេកម្មវិធី។

តើ Go អាចជួយរឿងនេះបានទេ? យើងបានដឹងថាវាអាចដោយសារតែភាសាចងក្រងកម្មវិធីចូលទៅក្នុងប្រព័ន្ធគោលពីរតែមួយ។ វាគឺជាវេទិកាឆ្លង; ប្រើ​គំរូ​ដំណើរការ​ស្រប​គ្នា (ស្រប​គ្នា) និង​បណ្ណាល័យ​សម្រាប់​ធ្វើការ​ជាមួយ HTTP; ហើយចុងក្រោយ បណ្ណាល័យប្រភពបើកចំហរាប់ពាន់ និងការរួមបញ្ចូលនឹងអាចរកបានសម្រាប់ពួកយើង។

ភាពលំបាកនៃការរួមបញ្ចូលភាសាសរសេរកម្មវិធីពីរ

ជាដំបូង ចាំបាច់ត្រូវកំណត់ថាតើកម្មវិធីពីរ ឬច្រើននឹងទាក់ទងគ្នាទៅវិញទៅមកយ៉ាងដូចម្តេច។

ឧទាហរណ៍ការប្រើ បណ្ណាល័យដ៏អស្ចារ្យ Alex Palaestras វាអាចចែករំលែកការចងចាំរវាងដំណើរការ PHP និង Go (ស្រដៀងទៅនឹង mod_php ក្នុង Apache)។ ប៉ុន្តែបណ្ណាល័យនេះមានលក្ខណៈពិសេសដែលកំណត់ការប្រើប្រាស់របស់វាសម្រាប់ការដោះស្រាយបញ្ហារបស់យើង។

យើងបានសម្រេចចិត្តប្រើវិធីសាស្រ្តសាមញ្ញជាងនេះទៅទៀត៖ ដើម្បីបង្កើតអន្តរកម្មរវាងដំណើរការតាមរយៈរន្ធ/បំពង់។ វិធីសាស្រ្តនេះបានបង្ហាញថាអាចទុកចិត្តបានក្នុងរយៈពេលជាច្រើនទសវត្សរ៍កន្លងមក ហើយត្រូវបានធ្វើឱ្យប្រសើរល្អនៅកម្រិតប្រព័ន្ធប្រតិបត្តិការ។

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

នៅលើផ្នែក PHP យើងបានប្រើ មុខងារកញ្ចប់ហើយនៅផ្នែក Go បណ្ណាល័យ ការអ៊ិនកូដ/ប្រព័ន្ធគោលពីរ.

វាហាក់ដូចជាពួកយើងថាពិធីការមួយមិនគ្រប់គ្រាន់ទេ ហើយយើងបានបន្ថែមសមត្ថភាពក្នុងការហៅទូរសព្ទ net/rpc ទៅសេវាកម្មដោយផ្ទាល់ពី PHP. ក្រោយមក វាបានជួយយើងយ៉ាងច្រើនក្នុងការអភិវឌ្ឍន៍ ដោយសារយើងអាចបញ្ចូល Go libraries ទៅក្នុងកម្មវិធី PHP បានយ៉ាងងាយស្រួល។ ឧទាហរណ៍ លទ្ធផលនៃការងារនេះអាចត្រូវបានគេមើលឃើញនៅក្នុងផលិតផលប្រភពបើកចំហផ្សេងទៀតរបស់យើង។ Goridge.

ការចែកចាយការងារលើកម្មករ PHP ជាច្រើន។

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

ដើម្បីរក្សាទុកអាងនៃកម្មករសកម្ម យើងបានប្រើ ឆានែលដែលជាប់គាំងដើម្បីដកកម្មករ "ស្លាប់" ដែលមិននឹកស្មានដល់ចេញពីអាង យើងបានបន្ថែមយន្តការសម្រាប់តាមដានកំហុស និងស្ថានភាពរបស់កម្មករ។

ជាលទ្ធផល យើងទទួលបានម៉ាស៊ីនមេ PHP ដែលកំពុងដំណើរការដែលមានសមត្ថភាពដំណើរការសំណើណាមួយដែលបង្ហាញក្នុងទម្រង់គោលពីរ។

ដើម្បីឱ្យកម្មវិធីរបស់យើងចាប់ផ្តើមធ្វើការជាម៉ាស៊ីនមេគេហទំព័រ យើងត្រូវជ្រើសរើសស្តង់ដារ PHP ដែលអាចទុកចិត្តបាន ដើម្បីតំណាងឱ្យសំណើ HTTP ចូល។ ក្នុងករណីរបស់យើងយើងគ្រាន់តែ បំប្លែង net/http សំណើពី Go to format PSR-7ដូច្នេះវាអាចប្រើបានជាមួយក្របខ័ណ្ឌ PHP ភាគច្រើនដែលមានសព្វថ្ងៃនេះ។

ដោយសារតែ PSR-7 ត្រូវបានចាត់ទុកថាមិនអាចផ្លាស់ប្តូរបាន (អ្នកខ្លះនិយាយថាវាមិនមែនជាបច្ចេកទេសទេ) អ្នកអភិវឌ្ឍន៍ត្រូវសរសេរកម្មវិធីដែលមិនចាត់ទុកសំណើជាអង្គភាពសកលជាគោលការណ៍។ វាសមនឹងគំនិតនៃដំណើរការ PHP ដែលមានអាយុកាលយូរ។ ការអនុវត្តចុងក្រោយរបស់យើង ដែលមិនទាន់មានឈ្មោះ មើលទៅដូចនេះ៖

សូមណែនាំ RoadRunner - ម៉ាស៊ីនមេកម្មវិធី PHP ដំណើរការខ្ពស់។

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

ដើម្បីជំនួសដំណោះស្រាយនេះ យើងបានដាក់ពង្រាយម៉ាស៊ីនមេកម្មវិធី PHP/Go ដំបូងរបស់យើងនៅដើមឆ្នាំ 2018 ។ ហើយទទួលបានប្រសិទ្ធភាពមិនគួរឱ្យជឿភ្លាមៗ! យើងមិនត្រឹមតែកម្ចាត់កំហុស 502 ទាំងស្រុងប៉ុណ្ណោះទេ ប៉ុន្តែយើងអាចកាត់បន្ថយចំនួនម៉ាស៊ីនមេបាន XNUMX/XNUMX ដោយសន្សំប្រាក់បានច្រើន និងថ្នាំឈឺក្បាលសម្រាប់វិស្វករ និងអ្នកគ្រប់គ្រងផលិតផល។

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

របៀបដែល RoadRunner អាចកែលម្អជង់អភិវឌ្ឍន៍របស់អ្នក។

កម្មវិធី អ្នកធ្វើដំណើរតាមផ្លូវ បានអនុញ្ញាតឱ្យយើងប្រើ Middleware net/http នៅផ្នែក Go ដើម្បីធ្វើការផ្ទៀងផ្ទាត់ JWT មុនពេលសំណើទៅដល់ PHP ក៏ដូចជាដោះស្រាយ WebSockets និងសរុបរដ្ឋជាសកលនៅក្នុង Prometheus ។

សូមអរគុណចំពោះ RPC ដែលភ្ជាប់មកជាមួយ អ្នកអាចបើក API នៃបណ្ណាល័យ Go ណាមួយសម្រាប់ PHP ដោយមិនចាំបាច់សរសេរកម្មវិធីបន្ថែម។ សំខាន់ជាងនេះទៅទៀត ជាមួយនឹង RoadRunner អ្នកអាចដាក់ពង្រាយម៉ាស៊ីនមេដែលមិនមែនជា HTTP ថ្មី។ ឧទាហរណ៍រួមមានកម្មវិធីដោះស្រាយដែលកំពុងដំណើរការនៅក្នុង PHP AWS Lambdaបង្កើតអ្នកបំបែកជួរដែលអាចទុកចិត្តបាន និងសូម្បីតែបន្ថែម gRPC ទៅកម្មវិធីរបស់យើង។

ដោយមានជំនួយពីសហគមន៍ PHP និង Go យើងបានធ្វើឱ្យប្រសើរឡើងនូវស្ថេរភាពនៃដំណោះស្រាយ បង្កើនការអនុវត្តកម្មវិធីរហូតដល់ 40 ដងក្នុងការធ្វើតេស្តមួយចំនួន ការកែលម្អឧបករណ៍បំបាត់កំហុស អនុវត្តការរួមបញ្ចូលជាមួយក្របខ័ណ្ឌ Symfony និងបន្ថែមការគាំទ្រសម្រាប់ HTTPS, HTTP/2, កម្មវិធីជំនួយ និង PSR-17 ។

សេចក្តីសន្និដ្ឋាន

មនុស្សមួយចំនួននៅតែត្រូវបានគេចាប់បាននៅក្នុងគំនិតហួសសម័យនៃ PHP ថាជាភាសាយឺត និងមិនមានសណ្តាប់ធ្នាប់ល្អសម្រាប់តែការសរសេរកម្មវិធីជំនួយសម្រាប់ WordPress ប៉ុណ្ណោះ។ មនុស្សទាំងនេះថែមទាំងអាចនិយាយថា PHP មានដែនកំណត់បែបនេះ៖ នៅពេលដែលកម្មវិធីធំល្មម អ្នកត្រូវជ្រើសរើសភាសា "ចាស់ទុំ" បន្ថែមទៀត ហើយសរសេរឡើងវិញនូវមូលដ្ឋានកូដដែលប្រមូលបានក្នុងរយៈពេលជាច្រើនឆ្នាំ។

ចំពោះរឿងទាំងអស់នេះខ្ញុំចង់ឆ្លើយ៖ គិតម្តងទៀត។ យើងជឿថាមានតែអ្នកកំណត់ការរឹតបន្តឹងណាមួយសម្រាប់ PHP ។ អ្នកអាចចំណាយពេលពេញមួយជីវិតរបស់អ្នកផ្លាស់ប្តូរពីភាសាមួយទៅភាសាមួយទៀត ដោយព្យាយាមស្វែងរកការផ្គូផ្គងដ៏ល្អឥតខ្ចោះសម្រាប់តម្រូវការរបស់អ្នក ឬអ្នកអាចចាប់ផ្តើមគិតពីភាសាជាឧបករណ៍។ គុណវិបត្តិនៃភាសាដូចជា PHP អាចជាហេតុផលសម្រាប់ភាពជោគជ័យរបស់វា។ ហើយប្រសិនបើអ្នកបញ្ចូលវាជាមួយភាសាផ្សេងទៀតដូចជា Go នោះអ្នកនឹងបង្កើតផលិតផលដែលមានឥទ្ធិពលជាងប្រសិនបើអ្នកត្រូវបានកំណត់ឱ្យប្រើភាសាណាមួយនោះទេ។

ដោយបានធ្វើការជាមួយក្រុម Go និង PHP យើងអាចនិយាយបានថាយើងស្រឡាញ់ពួកគេ។ យើងមិនមានគម្រោងលះបង់មួយសម្រាប់មួយផ្សេងទៀតនោះទេ - ផ្ទុយទៅវិញ យើងនឹងស្វែងរកវិធីដើម្បីទទួលបានតម្លៃកាន់តែច្រើនពីជង់ពីរនេះ។

UPD៖ យើងស្វាគមន៍អ្នកបង្កើត RoadRunner និងសហអ្នកនិពន្ធអត្ថបទដើម - ឡាចស៊ីស

ប្រភព: www.habr.com