ការផ្ទេរផ្នែកខាងក្រោយរបស់ PHP ទៅកាន់ Redis streams bus ហើយជ្រើសរើសបណ្ណាល័យឯករាជ្យនៃក្របខ័ណ្ឌ

បុព្វកថា

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

ការអនុវត្តគំនិត

កំណែដំបូងគឺគ្រាន់តែជាទំព័រ html នៅលើគេហទំព័រផ្ទាល់ខ្លួនរបស់ខ្ញុំ ដែលខ្ញុំដាក់តំណភ្ជាប់ដែលមានហត្ថលេខាទៅក្នុងបញ្ជី ul ។ ដោយបានវាយអត្ថបទចំនួន 20 ទំព័រក្នុងរយៈពេលមួយនោះ ខ្ញុំចាប់ផ្តើមគិតថាវាមិនសូវមានប្រសិទ្ធភាពទេ ហើយបានសម្រេចចិត្តព្យាយាមធ្វើស្វ័យប្រវត្តិកម្មដំណើរការនេះ។ នៅលើ stackoverflow ខ្ញុំបានកត់សម្គាល់ឃើញថាមនុស្សជាច្រើនបង្ហាញពីគេហទំព័រនៅក្នុងទម្រង់របស់ពួកគេ ដូច្នេះខ្ញុំបានសរសេរ parser នៅក្នុង php ដែលគ្រាន់តែឆ្លងកាត់ទម្រង់ដោយចាប់ផ្តើមពីដំបូង (អាសយដ្ឋាននៅលើ SO រហូតមកដល់សព្វថ្ងៃនេះគឺដូចនេះ៖ `/users/1` ) បានទាញយកតំណភ្ជាប់ពីស្លាកដែលចង់បាន ហើយបន្ថែមវានៅក្នុង SQLite ។

នេះអាចត្រូវបានគេហៅថាកំណែទីពីរ៖ បណ្តុំនៃ URLs រាប់ម៉ឺននៅក្នុងតារាង SQLite ដែលបានជំនួសបញ្ជីឋិតិវន្តនៅក្នុង HTML ។ ខ្ញុំបានស្វែងរកសាមញ្ញមួយក្នុងបញ្ជីនេះ។ ដោយសារតែ មានតែ URLs បន្ទាប់មកការស្វែងរកគឺផ្អែកលើពួកវា។

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

កំណែទំនើប

គម្រោង បានដាក់ពង្រាយនៅក្នុង Docker មូលដ្ឋានទិន្នន័យត្រូវបានផ្ទេរទៅ mongoDb ហើយថ្មីៗនេះ radish ត្រូវបានបន្ថែម ដែលដំបូងគឺគ្រាន់តែសម្រាប់ឃ្លាំងសម្ងាត់ប៉ុណ្ណោះ។ មួយនៃ PHP microframeworks ត្រូវបានប្រើជាមូលដ្ឋាន។

បញ្ហា

គេហទំព័រថ្មីត្រូវបានបន្ថែមដោយពាក្យបញ្ជាកុងសូលដែលធ្វើសមកាលកម្មដូចខាងក្រោមៈ

• ទាញយកមាតិកាដោយ URL
• កំណត់ទង់ដែលបង្ហាញថា HTTPS មានឬអត់
• រក្សាខ្លឹមសារនៃគេហទំព័រ
• ប្រភព HTML និងបឋមកថាត្រូវបានរក្សាទុកក្នុងប្រវត្តិ "ការធ្វើលិបិក្រម"
• ញែកខ្លឹមសារ ដកស្រង់ចំណងជើង និងការពិពណ៌នា
• រក្សាទុកទិន្នន័យទៅបណ្តុំដាច់ដោយឡែក

នេះគឺគ្រប់គ្រាន់ដើម្បីរក្សាទុកគេហទំព័រ និងបង្ហាញពួកវាក្នុងបញ្ជីមួយ៖

ប៉ុន្តែគំនិតនៃការធ្វើលិបិក្រមដោយស្វ័យប្រវត្តិ ចាត់ថ្នាក់ និងចាត់ថ្នាក់អ្វីៗគ្រប់យ៉ាង រក្សាអ្វីៗគ្រប់យ៉ាងឱ្យទាន់សម័យ មិនសមល្អទៅនឹងគំរូនេះទេ។ សូម្បីតែគ្រាន់តែបន្ថែមវិធីសាស្រ្តគេហទំព័រដើម្បីបន្ថែមទំព័រដែលទាមទារការចម្លងកូដ និងការទប់ស្កាត់ដើម្បីជៀសវាង DDoS ដែលមានសក្តានុពល។

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

ការសម្រេចចិត្ត

អនុវត្តជួរ និងបង្កើតប្រព័ន្ធដែលជំរុញដោយព្រឹត្តិការណ៍សម្រាប់ដំណើរការកិច្ចការទាំងអស់។ ហើយខ្ញុំចង់សាកល្បង Redis Stream ជាយូរមកហើយ។

ការប្រើប្រាស់ស្ទ្រីម Redis នៅក្នុង PHP

ដោយសារតែ ដោយសារក្របខណ្ឌរបស់ខ្ញុំមិនមែនជាក្រុមហ៊ុនយក្សទាំងបី Symfony, Laravel, Yii ខ្ញុំចង់ស្វែងរកបណ្ណាល័យឯករាជ្យមួយ។ ប៉ុន្តែ ដូចដែលវាបានប្រែក្លាយ (នៅលើការពិនិត្យដំបូង) វាមិនអាចទៅរួចទេក្នុងការស្វែងរកបណ្ណាល័យដ៏ធ្ងន់ធ្ងរនីមួយៗ។ អ្វី​គ្រប់​យ៉ាង​ដែល​ទាក់​ទង​នឹង​ជួរ​គឺ​ជា​គម្រោង​មួយ​ពី 3 ប្រព្រឹត្ត​កាល​ពី​ប្រាំ​ឆ្នាំ​មុន ឬ​ត្រូវ​បាន​ភ្ជាប់​ទៅ​នឹង​ក្របខ័ណ្ឌ។

ខ្ញុំបានលឺច្រើនអំពី Symfony ក្នុងនាមជាអ្នកផ្គត់ផ្គង់សមាសធាតុមានប្រយោជន៍បុគ្គល ហើយខ្ញុំបានប្រើប្រាស់ពួកវាមួយចំនួនរួចហើយ។ ហើយវត្ថុមួយចំនួនពី Laravel ក៏អាចត្រូវបានប្រើផងដែរ ឧទាហរណ៍ ORM របស់ពួកគេ ដោយគ្មានវត្តមាននៃក្របខ័ណ្ឌខ្លួនឯង។

symfony/messenger

បេក្ខជនទី XNUMX ហាក់ដូចជាល្អភ្លាមៗ ហើយដោយគ្មានការសង្ស័យ ខ្ញុំបានដំឡើងវា។ ប៉ុន្តែ​វា​បាន​ក្លាយ​ជា​ការ​ពិបាក​ជាង​ក្នុង​ការ​ប្រើ Google ឧទាហរណ៍​នៃ​ការ​ប្រើ​ក្រៅ Symfony ។ តើធ្វើដូចម្តេចដើម្បីប្រមូលផ្តុំពីក្រុមនៃថ្នាក់ដែលមានឈ្មោះជាសកលគ្មានន័យ, ឡានក្រុងសម្រាប់ការបញ្ជូនសារនិងសូម្បីតែនៅលើ Redis?

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

ការព្យាយាមរកវិធីធ្វើឱ្យប្រព័ន្ធភ្លាមៗដោយប្រើប្រភព Symfony ក៏មិនមែនជាកិច្ចការដ៏តូចបំផុតសម្រាប់ថ្ងៃកំណត់ដ៏តឹងរ៉ឹងដែរ៖

បន្ទាប់ពីស្វែងយល់ពីអ្វីៗទាំងអស់នេះ ហើយព្យាយាមធ្វើអ្វីមួយដោយដៃរបស់ខ្ញុំ ខ្ញុំបានសន្និដ្ឋានថា ខ្ញុំកំពុងធ្វើឈើច្រត់មួយប្រភេទ ហើយសម្រេចចិត្តសាកល្បងអ្វីផ្សេងទៀត។

បំភ្លឺ / ជួរ

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

yiisoft/yii2- ជួរ

ជាការប្រសើរណាស់, នៅទីនេះវាត្រូវបានសន្មត់ភ្លាមៗពីឈ្មោះ, ជាថ្មីម្តងទៀត, ការតភ្ជាប់យ៉ាងតឹងរឹងទៅ Yii2 ។ ខ្ញុំត្រូវប្រើបណ្ណាល័យនេះ ហើយវាមិនអាក្រក់ទេ ប៉ុន្តែខ្ញុំមិនបានគិតអំពីការពិតដែលថាវាអាស្រ័យទាំងស្រុងលើ Yii2 នោះទេ។

នៅសល់

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

ត្រឡប់ទៅ symfony/messenger, ព័ត៌មានលម្អិតបច្ចេកទេស

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

គ្រាន់តែពីរបីជំហានប៉ុណ្ណោះ៖

• យើងបង្កើតកម្មវិធីគ្រប់គ្រងសារ ដែលគួរតែអាចហៅបានយ៉ាងសាមញ្ញ
• យើងរុំពួកវានៅក្នុង HandlerDscriptor (ថ្នាក់ពីបណ្ណាល័យ)
• យើងរុំ "អ្នកពិពណ៌នា" ទាំងនេះនៅក្នុងឧទាហរណ៍ HandlersLocator
• ការបន្ថែម HandlersLocator ទៅក្នុងឧទាហរណ៍ MessageBus
• យើងបញ្ជូនសំណុំនៃ 'SenderInterface' ទៅ SenderLocator ក្នុងករណីរបស់ខ្ញុំនៃថ្នាក់ 'RedisTransport' ដែលត្រូវបានកំណត់រចនាសម្ព័ន្ធតាមរបៀបជាក់ស្តែង។
• ការបន្ថែម SenderLocator ទៅកាន់ MessageBus

MessageBus មានវិធីសាស្រ្ត `-> dispatch()` ដែលរកមើលអ្នកដោះស្រាយដែលសមរម្យនៅក្នុង HandlersLocator ហើយបញ្ជូនសារទៅពួកគេ ដោយប្រើ 'SenderInterface' ដែលត្រូវគ្នាដើម្បីផ្ញើតាមឡានក្រុង (ស្ទ្រីម Redis) ។

នៅក្នុងការកំណត់រចនាសម្ព័ន្ធកុងតឺន័រ (ក្នុងករណីនេះ php-di) កញ្ចប់ទាំងមូលនេះអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធដូចនេះ៖

        CONTAINER_REDIS_TRANSPORT_SECRET => function (ContainerInterface $c) {
            return new RedisTransport(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_SECRET),
                $c->get(CONTAINER_SERIALIZER))
            ;
        },
        CONTAINER_REDIS_TRANSPORT_LOG => function (ContainerInterface $c) {
            return new RedisTransport(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_LOG),
                $c->get(CONTAINER_SERIALIZER))
            ;
        },
        CONTAINER_REDIS_STREAM_RECEIVER_SECRET => function (ContainerInterface $c) {
            return new RedisReceiver(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_SECRET),
                $c->get(CONTAINER_SERIALIZER)
            );
        },
        CONTAINER_REDIS_STREAM_RECEIVER_LOG => function (ContainerInterface $c) {
            return new RedisReceiver(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_LOG),
                $c->get(CONTAINER_SERIALIZER)
            );
        },
        CONTAINER_REDIS_STREAM_BUS => function (ContainerInterface $c) {
            $sendersLocator = new SendersLocator([
                AppMessagesSecretJsonMessages::class => [CONTAINER_REDIS_TRANSPORT_SECRET],
                AppMessagesDaemonLogMessage::class => [CONTAINER_REDIS_TRANSPORT_LOG],
            ], $c);
            $middleware[] = new SendMessageMiddleware($sendersLocator);

            return new MessageBus($middleware);
        },
        CONTAINER_REDIS_STREAM_CONNECTION_SECRET => function (ContainerInterface $c) {
            $host = 'bu-02-redis';
            $port = 6379;
            $dsn = "redis://$host:$port";
            $options = [
                'stream' => 'secret',
                'group' => 'default',
                'consumer' => 'default',
            ];

            return Connection::fromDsn($dsn, $options);
        },
        CONTAINER_REDIS_STREAM_CONNECTION_LOG => function (ContainerInterface $c) {
            $host = 'bu-02-redis';
            $port = 6379;
            $dsn = "redis://$host:$port";
            $options = [
                'stream' => 'log',
                'group' => 'default',
                'consumer' => 'default',
            ];

            return Connection::fromDsn($dsn, $options);
        },

នៅទីនេះអ្នកអាចមើលឃើញថានៅក្នុង SenderLocator យើងបានកំណត់ "ការដឹកជញ្ជូន" ផ្សេងគ្នាសម្រាប់សារពីរផ្សេងគ្នា ដែលនីមួយៗមានទំនាក់ទំនងផ្ទាល់របស់វាទៅនឹងស្ទ្រីមដែលត្រូវគ្នា។

ខ្ញុំបានបង្កើតគម្រោងសាកល្បងដាច់ដោយឡែកមួយដែលបង្ហាញពីកម្មវិធីនៃដេមិនបីដែលទាក់ទងគ្នាទៅវិញទៅមកដោយប្រើឡានក្រុងខាងក្រោម៖ https://github.com/backend-university/products/tree/master/products/02-redis-streams-bus.

ប៉ុន្តែខ្ញុំនឹងបង្ហាញអ្នកពីរបៀបដែលអ្នកប្រើប្រាស់អាចមានរចនាសម្ព័ន្ធ៖

use AppMessagesDaemonLogMessage;
use SymfonyComponentMessengerHandlerHandlerDescriptor;
use SymfonyComponentMessengerHandlerHandlersLocator;
use SymfonyComponentMessengerMessageBus;
use SymfonyComponentMessengerMiddlewareHandleMessageMiddleware;
use SymfonyComponentMessengerMiddlewareSendMessageMiddleware;
use SymfonyComponentMessengerTransportSenderSendersLocator;

require_once __DIR__ . '/../vendor/autoload.php';
/** @var PsrContainerContainerInterface $container */
$container = require_once('config/container.php');

$handlers = [
    DaemonLogMessage::class => [
        new HandlerDescriptor(
            function (DaemonLogMessage $m) {
                error_log('DaemonLogHandler: message handled: / ' . $m->getMessage());
            },
            ['from_transport' => CONTAINER_REDIS_TRANSPORT_LOG]
        )
    ],
];
$middleware = [];
$middleware[] = new HandleMessageMiddleware(new HandlersLocator($handlers));
$sendersLocator = new SendersLocator(['*' => [CONTAINER_REDIS_TRANSPORT_LOG]], $container);
$middleware[] = new SendMessageMiddleware($sendersLocator);

$bus = new MessageBus($middleware);
$receivers = [
    CONTAINER_REDIS_TRANSPORT_LOG => $container->get(CONTAINER_REDIS_STREAM_RECEIVER_LOG),
];
$w = new SymfonyComponentMessengerWorker($receivers, $bus, $container->get(CONTAINER_EVENT_DISPATCHER));
$w->run();

ការប្រើប្រាស់ហេដ្ឋារចនាសម្ព័ន្ធនេះនៅក្នុងកម្មវិធីមួយ។

ដោយបានអនុវត្តឡានក្រុងនៅក្នុងផ្នែកខាងក្រោយរបស់ខ្ញុំ ខ្ញុំបានបំបែកដំណាក់កាលនីមួយៗចេញពីពាក្យបញ្ជា synchronous ចាស់ ហើយបង្កើតអ្នកដោះស្រាយដាច់ដោយឡែក ដែលម្នាក់ៗធ្វើរឿងផ្ទាល់ខ្លួន។

បំពង់សម្រាប់ការបន្ថែមគេហទំព័រថ្មីទៅមូលដ្ឋានទិន្នន័យមើលទៅដូចនេះ៖

ហើយភ្លាមៗបន្ទាប់ពីនោះ វាកាន់តែងាយស្រួលសម្រាប់ខ្ញុំក្នុងការបន្ថែមមុខងារថ្មី ឧទាហរណ៍ ការស្រង់ចេញ និងញែក Rss ។ ដោយសារតែ ដំណើរការនេះក៏ទាមទារមាតិកាដើម បន្ទាប់មកអ្នកដោះស្រាយកម្មវិធីទាញយកតំណ RSS ដូចជា WebsiteIndexHistoryPersistor ជាវសារ "មាតិកា / HtmlContent" ដំណើរការវា និងបញ្ជូនសារដែលចង់បានតាមបំពង់របស់វាបន្ថែមទៀត។

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

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

ប្រភព: www.habr.com