PHP backend-ის გადატანა Redis streams ავტობუსში და არჩევა ჩარჩო-დამოუკიდებელი ბიბლიოთეკა

წინასიტყვაობა

ჩემი ვებსაიტი, რომელსაც ვმუშაობ როგორც ჰობი, შექმნილია იმისთვის, რომ მასპინძლობს საინტერესო მთავარ გვერდებს და პერსონალურ საიტებს. ეს თემა მაინტერესებდა ჩემი პროგრამირების მოგზაურობის დასაწყისშივე; იმ მომენტში მე მოხიბლული ვიყავი დიდი პროფესიონალების პოვნამ, რომლებიც წერენ საკუთარ თავზე, თავიანთ ჰობიებსა და პროექტებზე. მათი აღმოჩენის ჩვევა დღემდე შემორჩენილია: თითქმის ყველა კომერციულ და არც თუ ისე კომერციულ საიტზე, ვაგრძელებ ძირში ყურებას ავტორების ბმულების მოსაძებნად.

იდეის განხორციელება

პირველი ვერსია იყო მხოლოდ html გვერდი ჩემს პერსონალურ ვებსაიტზე, სადაც ხელმოწერებით ვდებ ბმულებს ul სიაში. გარკვეული პერიოდის განმავლობაში 20 გვერდის აკრეფის შემდეგ დავიწყე ფიქრი, რომ ეს არ იყო ძალიან ეფექტური და გადავწყვიტე პროცესის ავტომატიზაცია. stackoverflow-ზე შევამჩნიე, რომ ბევრი ადამიანი მიუთითებს საიტებზე თავის პროფილებში, ამიტომ დავწერე პარსერი php-ში, რომელიც უბრალოდ გადიოდა პროფილებში, დაწყებული პირველიდან (SO-ზე მისამართები დღემდე ასეთია: `/users/1` ), ამოიღო ბმულები სასურველი ტეგიდან და დაამატა SQLite-ში.

ამას შეიძლება ეწოდოს მეორე ვერსია: ათიათასობით URL-ის კოლექცია SQLite ცხრილში, რომელმაც ჩაანაცვლა სტატიკური სია HTML-ში. მარტივი ძიება გავაკეთე ამ სიაში. იმიტომ რომ იყო მხოლოდ URL-ები, შემდეგ ძიება უბრალოდ მათზე იყო დაფუძნებული.

ამ ეტაპზე მივატოვე პროექტი და დიდი ხნის შემდეგ დავუბრუნდი მას. ამ ეტაპზე ჩემი სამუშაო გამოცდილება უკვე სამ წელზე მეტი იყო და ვგრძნობდი, რომ უფრო სერიოზული რამის გაკეთება შემეძლო. გარდა ამისა, დიდი იყო სურვილი, დაეუფლონ შედარებით ახალ ტექნოლოგიებს.

თანამედროვე ვერსია

პროექტი Docker-ში განლაგებული, მონაცემთა ბაზა გადავიდა mongoDb-ზე და ახლახანს დაემატა რადიშ, რომელიც თავიდან მხოლოდ ქეშირებისთვის იყო. ერთ-ერთი PHP მიკროჩარჩო გამოიყენება საფუძვლად.

პრობლემა

ახალი საიტები ემატება კონსოლის ბრძანებით, რომელიც სინქრონულად აკეთებს შემდეგს:

• იტვირთება შინაარსი URL-ით
• აყენებს დროშას, რომელიც მიუთითებს ხელმისაწვდომი იყო თუ არა HTTPS
• ინარჩუნებს საიტის არსს
• წყაროს HTML და სათაურები ინახება „ინდექსირების“ ისტორიაში
• აანალიზებს შინაარსს, ამონაწერს სათაურსა და აღწერას
• ინახავს მონაცემებს ცალკეულ კოლექციაში

ეს საკმარისი იყო საიტების უბრალოდ შესანახად და სიაში გამოსატანად:

მაგრამ ყველაფრის ავტომატური ინდექსირების, კატეგორიზაციისა და რეიტინგის, ყველაფრის განახლების იდეა კარგად არ ჯდებოდა ამ პარადიგმაში. თუნდაც უბრალოდ ვებ მეთოდის დამატება გვერდების დასამატებლად, საჭიროა კოდის დუბლირება და დაბლოკვა, რათა თავიდან იქნას აცილებული პოტენციური DDoS.

ზოგადად, რა თქმა უნდა, ყველაფრის გაკეთება შესაძლებელია სინქრონულად და ვებ მეთოდით შეგიძლიათ უბრალოდ შეინახოთ URL ისე, რომ ამაზრზენი დემონი შეასრულოს ყველა დავალება სიიდან URL-ებისთვის. მაგრამ მაინც, აქაც სიტყვა „რიგი“ თავს იჩენს. და თუ რიგი განხორციელებულია, მაშინ ყველა დავალება შეიძლება დაიყოს და შესრულდეს მინიმუმ ასინქრონულად.

გადაწყვეტილება

განახორციელეთ რიგები და შექმენით მოვლენებზე ორიენტირებული სისტემა ყველა ამოცანის დასამუშავებლად. და მე დიდი ხანია მინდა ვცადო Redis Streams.

Redis ნაკადების გამოყენება PHP-ში

იმიტომ რომ ვინაიდან ჩემი ჩარჩო არ არის სამი გიგანტიდან ერთ-ერთი Symfony, Laravel, Yii, მსურს ვიპოვო დამოუკიდებელი ბიბლიოთეკა. მაგრამ, როგორც გაირკვა (პირველი შემოწმებისას), ცალკეული სერიოზული ბიბლიოთეკების პოვნა შეუძლებელია. რიგებთან დაკავშირებული ყველაფერი ან არის ხუთი წლის წინანდელი 3 ჩადენის პროექტი, ან მიბმული ჩარჩოზე.

ბევრი მსმენია Symfony-ზე, როგორც ინდივიდუალური სასარგებლო კომპონენტების მიმწოდებლის შესახებ და უკვე ვიყენებ ზოგიერთ მათგანს. ასევე შესაძლებელია Laravel-ის ზოგიერთი ნივთის გამოყენება, მაგალითად, მათი ORM, თავად ფრეიმერის არსებობის გარეშე.

სიმფონია/მესენჯერი

პირველი კანდიდატი მაშინვე იდეალური მეჩვენა და უეჭველად დავაყენე. მაგრამ უფრო რთული აღმოჩნდა Symfony-ის გარეთ გამოყენების მაგალითების გუგლი. როგორ შევიკრიბოთ კლასებიდან უნივერსალური, უაზრო სახელებით, ავტობუსი შეტყობინებების გადასაცემად და თუნდაც Redis-ზე?

ოფიციალურ საიტზე დოკუმენტაცია საკმაოდ დეტალური იყო, მაგრამ ინიციალიზაცია მხოლოდ Symfony-სთვის იყო აღწერილი მათი საყვარელი YML და სხვა ჯადოსნური მეთოდების გამოყენებით არასიმფონისტებისთვის. არ მაინტერესებდა თავად ინსტალაციის პროცესი, განსაკუთრებით საახალწლო არდადეგების დროს. მაგრამ მე ამის გაკეთება მოულოდნელად დიდი ხნის განმავლობაში მომიწია.

იმის გარკვევა, თუ როგორ უნდა შექმნათ სისტემა Symfony-ის წყაროების გამოყენებით, ასევე არ არის ყველაზე ტრივიალური ამოცანა მჭიდრო ვადით:

ამ ყველაფერში ჩაღრმავების და ხელებით რაღაცის გაკეთების შემდეგ მივედი იმ დასკვნამდე, რომ რაღაც ყავარჯნებს ვაკეთებდი და გადავწყვიტე სხვა რამ მეცადა.

განათებული/რიგი

აღმოჩნდა, რომ ეს ბიბლიოთეკა მჭიდროდ იყო მიბმული Laravel-ის ინფრასტრუქტურასთან და სხვა დამოკიდებულებებთან, ამიტომ მასზე დიდი დრო არ დავხარჯე: დავაინსტალირე, დავაკვირდი, ვნახე დამოკიდებულებები და წავშალე.

yiisoft/yii2-რიგი

კარგად, აქ მაშინვე ვივარაუდოთ სახელიდან, ისევ მკაცრი კავშირი Yii2-თან. მე მომიწია ამ ბიბლიოთეკის გამოყენება და ეს არ იყო ცუდი, მაგრამ არ მიფიქრია იმაზე, რომ ეს მთლიანად დამოკიდებულია Yii2-ზე.

სხვა

ყველაფერი, რაც აღმოვაჩინე GitHub-ზე, იყო არასანდო, მოძველებული და მიტოვებული პროექტები ვარსკვლავების, ჩანგლებისა და დიდი რაოდენობის ვალდებულებების გარეშე.

დაბრუნება symfony/messenger-ზე, ტექნიკურ დეტალებზე

მე უნდა გამეგო ეს ბიბლიოთეკა და, გარკვეული დროის გატარების შემდეგ, შევძელი. აღმოჩნდა, რომ ყველაფერი საკმაოდ ლაკონური და მარტივი იყო. ავტობუსის გამოსაყენებლად პატარა ქარხანა გავაკეთე, რადგან... მე უნდა მქონოდა რამდენიმე საბურავი და სხვადასხვა ტარებით.

სულ რამდენიმე ნაბიჯი:

• ჩვენ ვქმნით შეტყობინებების დამმუშავებლებს, რომლებიც უბრალოდ გამოძახებადი უნდა იყოს
• ჩვენ ვახვევთ მათ HandlerDescriptor-ში (კლასი ბიბლიოთეკიდან)
• ჩვენ ვახვევთ ამ „აღმწერებს“ HandlersLocator-ის მაგალითში
• HandlersLocator-ის დამატება MessageBus მაგალითზე
• ჩვენ გადავცემთ `SenderInterface`-ის კომპლექტს SendersLocator-ს, ჩემს შემთხვევაში `RedisTransport` კლასების მაგალითებს, რომლებიც კონფიგურირებულია აშკარად.
• SendersLocator-ის დამატება 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);
        },

აქ ხედავთ, რომ 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, გამოიწერს შეტყობინებას „Content/HtmlContent“, ამუშავებს მას და გადასცემს სასურველ შეტყობინებას მისი მილსადენის გასწვრივ.

საბოლოოდ, ჩვენ მივიღეთ რამდენიმე დემონი, რომელთაგან თითოეული ინარჩუნებს კავშირს მხოლოდ საჭირო რესურსებთან. მაგალითად დემონი crawlers შეიცავს ყველა დამმუშავებელს, რომელიც მოითხოვს ინტერნეტში შესვლას შინაარსისთვის და დემონს გაგრძელდეს ფლობს კავშირს მონაცემთა ბაზასთან.

ახლა, მონაცემთა ბაზიდან არჩევის ნაცვლად, საჭირო ID-ები მუდმივი ჩასმის შემდეგ უბრალოდ ავტობუსით გადაეცემა ყველა დაინტერესებულ დამმუშავებელს.

წყარო: www.habr.com