העברת קצה ה-PHP לאפיק הזרמים של Redis ובחירה בספרייה עצמאית מסגרת

פְּתִיחַ

האתר שלי, אותו אני מנהל כתחביב, מיועד לארח דפי בית ואתרים אישיים מעניינים. הנושא הזה התחיל לעניין אותי ממש בתחילת מסע התכנות שלי; באותו רגע הוקסמתי מלמצוא אנשי מקצוע מעולים שכותבים על עצמם, על התחביבים והפרויקטים שלהם. ההרגל לגלות אותם בעצמי נשאר עד היום: כמעט בכל אתר מסחרי ולא מאוד מסחרי, אני ממשיך לחפש בכותרת התחתונה בחיפוש אחר קישורים לכותבים.

יישום הרעיון

הגרסה הראשונה הייתה רק דף 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 שלהם, ללא נוכחות המסגרת עצמה.

סימפוניה/מסנג'ר

המועמד הראשון נראה מיד אידיאלי וללא כל ספק התקנתי אותו. אבל התברר שקשה יותר לחפש בגוגל דוגמאות לשימוש מחוץ לסימפוני. איך להרכיב מחבורה של כיתות עם שמות אוניברסליים וחסרי משמעות, אוטובוס להעברת הודעות ואפילו על Redis?

התיעוד באתר הרשמי היה מפורט למדי, אבל האתחול תואר רק עבור סימפוניה באמצעות YML האהובים עליהם ושיטות קסם אחרות עבור הלא-סימפוניסט. לא היה לי עניין בתהליך ההתקנה עצמו, במיוחד בחופשות ראש השנה. אבל הייתי צריך לעשות את זה במשך זמן רב באופן בלתי צפוי.

הניסיון להבין כיצד להפעיל מערכת באמצעות מקורות סימפוניה היא גם לא המשימה הטריוויאלית ביותר עבור דדליין קצר:

אחרי שהתעמקתי בכל זה וניסיתי לעשות משהו עם הידיים, הגעתי למסקנה שאני עושה סוג של קביים והחלטתי לנסות משהו אחר.

מואר/תור

התברר שהספרייה הזו הייתה קשורה באופן הדוק לתשתית Laravel ולעוד המון תלות, אז לא השקעתי בה הרבה זמן: התקנתי אותה, הסתכלתי עליה, ראיתי את התלות ומחקתי אותה.

yiisoft/yii2-queue

ובכן, כאן הונח מיד מהשם, שוב, קשר קפדני ל-Yii2. הייתי צריך להשתמש בספרייה הזו וזה לא היה רע, אבל לא חשבתי על זה שזה לגמרי תלוי ב-Yii2.

השאר

כל השאר שמצאתי ב-GitHub היו פרויקטים לא אמינים, מיושנים ונטושים ללא כוכבים, מזלגות ומספר רב של מחויבות.

חזרה לסימפוניה/מסנג'ר, פרטים טכניים

הייתי צריך להבין את הספרייה הזו, ואחרי שביליתי עוד זמן, הצלחתי. התברר שהכל היה די תמציתי ופשוט. כדי ליצור את האוטובוס, יצרתי מפעל קטן, כי... היו אמורים להיות לי כמה צמיגים ועם מטפלים שונים.

רק כמה צעדים:

• אנו יוצרים מטפלי הודעות שפשוט צריכים להיות ניתנים להתקשרות
• אנו עוטפים אותם ב- HandlerDescriptor (כיתה מהספרייה)
• אנו עוטפים את ה"תיאורים" הללו במופע HandlersLocator
• הוספת HandlersLocator למופע MessageBus
• אנו מעבירים קבוצה של 'SenderInterface' ל-SendersLocator, במקרה שלי מקרים של מחלקות 'RedisTransport', המוגדרות בצורה ברורה
• הוספת SendersLocator למופע MessageBus

ל-MessageBus יש שיטה של ​​`->dispatch()` שמחפשת את המטפלים המתאימים ב- HandlersLocator ומעבירה להם את ההודעה, תוך שימוש ב-`SenderInterface` המקביל לשליחה דרך האוטובוס (Redis streams).

בתצורת המכולה (במקרה זה 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();

שימוש בתשתית זו באפליקציה

לאחר שהטמעתי את האוטובוס ב-backend שלי, הפרדתי שלבים בודדים מהפקודה הסינכרונית הישנה והכנתי מטפלים נפרדים, שכל אחד מהם עושה את שלו.

הצינור להוספת אתר חדש למסד הנתונים נראה כך:

ומיד לאחר מכן, היה לי הרבה יותר קל להוסיף פונקציונליות חדשה, למשל, חילוץ וניתוח Rss. כי תהליך זה דורש גם את התוכן המקורי, ואז המטפל בחילוץ קישורי RSS, כמו WebsiteIndexHistoryPersistor, נרשם להודעת "Content/HtmlContent", מעבד אותה ומעביר את ההודעה הרצויה לאורך הצינור שלה.

בסופו של דבר, הגענו לכמה דמונים, שכל אחד מהם שומר על קשרים רק למשאבים הדרושים. למשל שד סורקים מכיל את כל המטפלים שדורשים כניסה לאינטרנט לתוכן, ואת הדמון להתמיד מחזיק בחיבור למסד הנתונים.

כעת, במקום לבחור מתוך מסד הנתונים, המזהים הנדרשים לאחר הוספה על ידי המתמיד מועברים פשוט דרך האוטובוס לכל המטפלים המעוניינים בכך.

מקור: www.habr.com