PHP બેકએન્ડને Redis સ્ટ્રીમ બસમાં સ્થાનાંતરિત કરવું અને ફ્રેમવર્ક-સ્વતંત્ર લાઇબ્રેરી પસંદ કરવી

ફોરવર્ડ

મારી વેબસાઇટ, જે હું એક શોખ તરીકે ચલાવું છું, તે રસપ્રદ હોમ પેજ અને વ્યક્તિગત સાઇટ્સને હોસ્ટ કરવા માટે ડિઝાઇન કરવામાં આવી છે. મારી પ્રોગ્રામિંગ સફરની શરૂઆતમાં જ આ વિષય મને રસ લેવા લાગ્યો; તે ક્ષણે હું એવા મહાન વ્યાવસાયિકોને શોધીને આકર્ષિત થયો કે જેઓ પોતાના વિશે, તેમના શોખ અને પ્રોજેક્ટ્સ વિશે લખે છે. મારા માટે તેમને શોધવાની આદત આજે પણ છે: લગભગ દરેક વ્યવસાયિક અને ખૂબ જ વ્યવસાયિક સાઇટ પર નહીં, હું લેખકોની લિંક્સની શોધમાં ફૂટર જોવાનું ચાલુ રાખું છું.

વિચારનો અમલ

પ્રથમ સંસ્કરણ મારી વ્યક્તિગત વેબસાઇટ પર માત્ર એક HTML પૃષ્ઠ હતું, જ્યાં મેં સહીઓ સાથેની લિંક્સ ul સૂચિમાં મૂકી હતી. સમયાંતરે 20 પૃષ્ઠો ટાઇપ કર્યા પછી, મેં વિચારવાનું શરૂ કર્યું કે આ ખૂબ અસરકારક નથી અને પ્રક્રિયાને સ્વચાલિત કરવાનો પ્રયાસ કરવાનું નક્કી કર્યું. સ્ટેકઓવરફ્લો પર, મેં જોયું કે ઘણા લોકો તેમની પ્રોફાઇલમાં સાઇટ્સ સૂચવે છે, તેથી મેં php માં એક પાર્સર લખ્યું, જે ફક્ત પ્રથમથી શરૂ કરીને પ્રોફાઇલ્સમાંથી પસાર થયું (SO પર આજ સુધીના સરનામાં આના જેવા છે: `/users/1` ), ઇચ્છિત ટૅગમાંથી લિંક્સ કાઢી અને તેને SQLite માં ઉમેર્યું.

આને બીજું સંસ્કરણ કહી શકાય: SQLite કોષ્ટકમાં હજારો URL નો સંગ્રહ, જેણે HTML માં સ્થિર સૂચિનું સ્થાન લીધું. મેં આ સૂચિ પર એક સરળ શોધ કરી. કારણ કે ત્યાં ફક્ત URL હતા, પછી શોધ ફક્ત તેમના પર આધારિત હતી.

આ તબક્કે મેં પ્રોજેક્ટ છોડી દીધો અને લાંબા સમય પછી તેના પર પાછો ફર્યો. આ તબક્કે, મારો કાર્ય અનુભવ ત્રણ વર્ષથી વધુનો હતો અને મને લાગ્યું કે હું કંઈક વધુ ગંભીર કરી શકું છું. આ ઉપરાંત, પ્રમાણમાં નવી તકનીકોમાં નિપુણતા મેળવવાની મોટી ઇચ્છા હતી.

આધુનિક સંસ્કરણ

આ પ્રોજેક્ટ ડોકરમાં તૈનાત, ડેટાબેઝ mongoDb માં સ્થાનાંતરિત કરવામાં આવ્યો હતો, અને તાજેતરમાં જ, મૂળો ઉમેરવામાં આવ્યો હતો, જે શરૂઆતમાં ફક્ત કેશીંગ માટે હતો. PHP માઇક્રોફ્રેમવર્કમાંથી એકનો ઉપયોગ આધાર તરીકે થાય છે.

સમસ્યા

નવી સાઇટ્સ કન્સોલ કમાન્ડ દ્વારા ઉમેરવામાં આવે છે જે સિંક્રનસ રીતે નીચેના કરે છે:

• URL દ્વારા સામગ્રી ડાઉનલોડ કરે છે
• HTTPS ઉપલબ્ધ હતું કે કેમ તે દર્શાવતો ધ્વજ સેટ કરે છે
• વેબસાઇટનો સાર સાચવે છે
• સ્ત્રોત HTML અને હેડરો "ઇન્ડેક્સીંગ" ઇતિહાસમાં સાચવવામાં આવે છે
• સામગ્રીનું વિશ્લેષણ કરે છે, શીર્ષક અને વર્ણન અર્ક કરે છે
• ડેટાને અલગ સંગ્રહમાં સાચવે છે

આ ફક્ત સાઇટ્સને સ્ટોર કરવા અને તેમને સૂચિમાં પ્રદર્શિત કરવા માટે પૂરતું હતું:

પરંતુ દરેક વસ્તુનું આપમેળે અનુક્રમણિકા, વર્ગીકરણ અને ક્રમાંકિત કરવાનો વિચાર, દરેક વસ્તુને અદ્યતન રાખવા, આ દાખલામાં સારી રીતે બંધ બેસતો નથી. સંભવિત DDoS ને ટાળવા માટે પૃષ્ઠોને જરૂરી કોડ ડુપ્લિકેશન અને અવરોધિત કરવા માટે ફક્ત વેબ પદ્ધતિ ઉમેરવી.

સામાન્ય રીતે, અલબત્ત, બધું સિંક્રનસ રીતે કરી શકાય છે, અને વેબ પદ્ધતિમાં તમે ફક્ત URL ને સાચવી શકો છો જેથી રાક્ષસી ડિમન સૂચિમાંથી URL માટેના તમામ કાર્યો કરે. પરંતુ તેમ છતાં, અહીં પણ "કતાર" શબ્દ પોતાને સૂચવે છે. અને જો કતાર લાગુ કરવામાં આવે છે, તો પછી બધા કાર્યોને વિભાજિત કરી શકાય છે અને ઓછામાં ઓછા અસુમેળ રીતે કરી શકાય છે.

નિર્ણય

તમામ કાર્યોની પ્રક્રિયા કરવા માટે કતારોનો અમલ કરો અને ઇવેન્ટ-આધારિત સિસ્ટમ બનાવો. અને હું લાંબા સમયથી રેડિસ સ્ટ્રીમ્સ અજમાવવા માંગુ છું.

PHP માં Redis સ્ટ્રીમ્સનો ઉપયોગ કરવો

કારણ કે મારું માળખું ત્રણ જાયન્ટ્સ સિમ્ફોની, લારાવેલ, યીઆઈમાંથી એક નથી, તેથી હું એક સ્વતંત્ર પુસ્તકાલય શોધવા માંગુ છું. પરંતુ, જેમ તે બહાર આવ્યું છે (પ્રથમ પરીક્ષા પર), વ્યક્તિગત ગંભીર પુસ્તકાલયો શોધવાનું અશક્ય છે. કતારોને લગતી દરેક વસ્તુ કાં તો પાંચ વર્ષ પહેલા 3 કમિટનો પ્રોજેક્ટ છે, અથવા ફ્રેમવર્ક સાથે જોડાયેલી છે.

મેં વ્યક્તિગત ઉપયોગી ઘટકોના સપ્લાયર તરીકે સિમ્ફોની વિશે ઘણું સાંભળ્યું છે, અને હું તેમાંથી કેટલાકનો પહેલેથી જ ઉપયોગ કરું છું. અને લારાવેલમાંથી કેટલીક વસ્તુઓનો પણ ઉપયોગ કરી શકાય છે, ઉદાહરણ તરીકે તેમના ORM, ફ્રેમવર્કની હાજરી વિના.

સિમ્ફોની/મેસેન્જર

પ્રથમ ઉમેદવાર તરત જ આદર્શ લાગ્યો અને કોઈ શંકા વિના મેં તેને ઇન્સ્ટોલ કર્યું. પરંતુ સિમ્ફોનીની બહારના ઉપયોગના ઉદાહરણો ગૂગલ કરવા માટે તે વધુ મુશ્કેલ બન્યું. સાર્વત્રિક, અર્થહીન નામો, સંદેશાઓ પસાર કરવા માટેની બસ અને રેડિસ પર પણ વર્ગોના સમૂહમાંથી કેવી રીતે એસેમ્બલ કરવું?

અધિકૃત સાઇટ પરના દસ્તાવેજો ખૂબ વિગતવાર હતા, પરંતુ આરંભનું વર્ણન ફક્ત સિમ્ફોની માટે તેમના મનપસંદ YML અને બિન-સિમ્ફોનિસ્ટ માટે અન્ય જાદુ પદ્ધતિઓનો ઉપયોગ કરીને કરવામાં આવ્યું હતું. મને ઇન્સ્ટોલેશન પ્રક્રિયામાં જ કોઈ રસ નહોતો, ખાસ કરીને નવા વર્ષની રજાઓ દરમિયાન. પરંતુ મારે આ અનપેક્ષિત રીતે લાંબા સમય સુધી કરવું પડ્યું.

સિમ્ફોની સ્ત્રોતોનો ઉપયોગ કરીને સિસ્ટમને કેવી રીતે ઇન્સ્ટન્ટેટ કરવી તે શોધવાનો પ્રયાસ કરવો એ પણ ચુસ્ત સમયમર્યાદા માટે સૌથી તુચ્છ કાર્ય નથી:

આ બધાની તપાસ કર્યા પછી અને મારા હાથથી કંઈક કરવાનો પ્રયાસ કર્યા પછી, હું એવા નિષ્કર્ષ પર આવ્યો કે હું કોઈ પ્રકારની ક્રૉચ કરી રહ્યો છું અને કંઈક બીજું અજમાવવાનું નક્કી કર્યું.

પ્રકાશિત/કતાર

તે બહાર આવ્યું છે કે આ પુસ્તકાલય લારાવેલ ઇન્ફ્રાસ્ટ્રક્ચર અને અન્ય નિર્ભરતાના સમૂહ સાથે ચુસ્તપણે જોડાયેલું છે, તેથી મેં તેના પર વધુ સમય પસાર કર્યો નથી: મેં તેને ઇન્સ્ટોલ કર્યું, તેને જોયું, અવલંબન જોયું અને તેને કાઢી નાખ્યું.

yiisoft/yii2-કતાર

ઠીક છે, અહીં તે તરત જ નામ પરથી ધારવામાં આવ્યું હતું, ફરીથી, Yii2 સાથે કડક જોડાણ. મારે આ લાઇબ્રેરીનો ઉપયોગ કરવો પડ્યો હતો અને તે ખરાબ નહોતું, પરંતુ મેં એ હકીકત વિશે વિચાર્યું ન હતું કે તે સંપૂર્ણપણે Yii2 પર આધારિત છે.

બાકીના

GitHub પર મને જે બીજું બધું મળ્યું તે અવિશ્વસનીય, જૂના અને ત્યજી દેવાયેલા પ્રોજેક્ટ્સ હતા જેમાં તારાઓ, ફોર્ક અને મોટી સંખ્યામાં કમિટ નથી.

સિમ્ફોની/મેસેન્જર, તકનીકી વિગતો પર પાછા ફરો

મારે આ પુસ્તકાલયની શોધ કરવી હતી અને થોડો વધુ સમય વિતાવ્યા પછી, હું સક્ષમ બન્યો. તે બહાર આવ્યું છે કે બધું એકદમ સંક્ષિપ્ત અને સરળ હતું. બસ ચાલુ કરવા માટે, મેં એક નાનું કારખાનું બનાવ્યું, કારણ કે... મારી પાસે ઘણા ટાયર અને જુદા જુદા હેન્ડલર્સ હોવાના હતા.

માત્ર થોડા પગલાં:

• અમે મેસેજ હેન્ડલર્સ બનાવીએ છીએ જે ફક્ત કૉલ કરવા યોગ્ય હોવા જોઈએ
• અમે તેમને હેન્ડલરડેસ્ક્રીપ્ટરમાં લપેટીએ છીએ (લાઇબ્રેરીમાંથી વર્ગ)
• અમે આ "વર્ણનકર્તાઓ" ને હેન્ડલર્સલોકેટર ઉદાહરણમાં લપેટીએ છીએ
• હેન્ડલર્સલોકેટરને મેસેજબસ દાખલામાં ઉમેરી રહ્યા છે
• અમે સેન્ડરલોકેટરને `સેન્ડરઇંટરફેસ`નો સમૂહ પસાર કરીએ છીએ, મારા કિસ્સામાં `રેડિસટ્રાન્સપોર્ટ` વર્ગોના ઉદાહરણો, જે સ્પષ્ટ રીતે ગોઠવેલ છે.
• MessageBus ઉદાહરણમાં SendersLocator ઉમેરવાનું

મેસેજબસ પાસે `->ડિસ્પેચ()` પદ્ધતિ છે જે હેન્ડલર્સલોકેટરમાં યોગ્ય હેન્ડલર્સને જુએ છે અને બસ (રેડીસ સ્ટ્રીમ્સ) દ્વારા મોકલવા માટે અનુરૂપ `સેન્ડર ઈન્ટરફેસ` નો ઉપયોગ કરીને તેમને સંદેશ મોકલે છે.

કન્ટેનર રૂપરેખાંકનમાં (આ કિસ્સામાં 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);
        },

અહીં તમે જોઈ શકો છો કે SendersLocator માં અમે બે અલગ-અલગ સંદેશાઓ માટે અલગ-અલગ "પરિવહન" અસાઇન કર્યા છે, જેમાંના દરેકનું અનુરૂપ સ્ટ્રીમ્સ સાથેનું પોતાનું જોડાણ છે.

મેં નીચેની બસનો ઉપયોગ કરીને એકબીજા સાથે વાતચીત કરતા ત્રણ ડિમનની એપ્લિકેશન દર્શાવતો એક અલગ ડેમો પ્રોજેક્ટ બનાવ્યો: 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();

એપ્લિકેશનમાં આ ઈન્ફ્રાસ્ટ્રક્ચરનો ઉપયોગ કરવો

બસને મારા બેકએન્ડમાં અમલમાં મૂક્યા પછી, મેં જૂના સિંક્રનસ કમાન્ડમાંથી વ્યક્તિગત તબક્કાઓને અલગ કર્યા અને અલગ હેન્ડલર્સ બનાવ્યા, જેમાંથી દરેક પોતપોતાનું કામ કરે છે.

ડેટાબેઝમાં નવી સાઇટ ઉમેરવા માટેની પાઇપલાઇન આના જેવી દેખાતી હતી:

અને તે પછી તરત જ, મારા માટે નવી કાર્યક્ષમતા ઉમેરવાનું ખૂબ સરળ બન્યું, ઉદાહરણ તરીકે, Rss ને એક્સટ્રેક્ટ અને પાર્સિંગ. કારણ કે આ પ્રક્રિયા માટે મૂળ સામગ્રીની પણ જરૂર પડે છે, પછી RSS લિંક એક્સટ્રેક્ટર હેન્ડલર, જેમ કે WebsiteIndexHistoryPersistor, "સામગ્રી/HtmlContent" સંદેશને સબ્સ્ક્રાઇબ કરે છે, તેની પ્રક્રિયા કરે છે અને ઇચ્છિત સંદેશને તેની પાઇપલાઇન સાથે આગળ પસાર કરે છે.

અંતે, અમે ઘણા ડિમન સાથે સમાપ્ત થયા, જેમાંથી દરેક ફક્ત જરૂરી સંસાધનો સાથે જોડાણ જાળવે છે. ઉદાહરણ તરીકે, એક રાક્ષસ ક્રોલર્સ સામગ્રી માટે ઈન્ટરનેટ પર જવાની જરૂર હોય તેવા તમામ હેન્ડલર્સ અને ડિમન સમાવે છે ટકી રહેવું ડેટાબેઝ સાથે જોડાણ ધરાવે છે.

હવે, ડેટાબેઝમાંથી પસંદ કરવાને બદલે, પર્સિસ્ટર દ્વારા દાખલ કર્યા પછી જરૂરી આઈડી બસ દ્વારા બધા રસ ધરાવતા હેન્ડલર્સને ટ્રાન્સમિટ કરવામાં આવે છે.

સોર્સ: www.habr.com