استخدام Pub/Sub من Scala
تحتاج أنظمة الخدمات المصغّرة (وكثير غيرها) في الغالب إلى أن تتواصل الخدمات فيما بينها بشكل غير متزامن عبر طبقة رسائل ما. يُعدّ Google Pub/Sub، الذي تقدّمه Google مباشرة ضمن GCP، خيارًا مناسبًا لذلك: أقل تعقيدًا من Kafka، لكنه بسيط في العمل ولا يتطلب أي صيانة.
ما هو Pub/Sub
تتطلب معماريات الخدمات المصغّرة (وليست وحدها) في أغلب الأحيان تواصلًا غير متزامن بين الخدمات يقوم على حل رسائل ما. وهناك مجموعة واسعة من الخيارات في هذه المرحلة، بدءًا من إعداد RabbitMQ على عقدة واحدة وصولًا إلى عنقود Kafka متعدد العقد بالكامل. يمثّل Google Pub/Sub رؤية Google للتواصل غير المتزامن، وهو متاح مباشرة داخل GCP من Google – وهو أقل تقدمًا من Kafka، لكنه في المقابل سهل الاستخدام ولا يحتاج إلى أي صيانة.
يتيح لك Pub/Sub بناء نظام من المنتِجين والمستهلكين لأحداثك. يدفع المنتِجون الأحداث إلى خدمة Pub/Sub دون أن يعرفوا متى ستُعالَج أو كيف، ثم تحاول خدمة Pub/Sub تسليم كل رسالة من تلك الرسائل إلى المشتركين المعرَّفين مسبقًا.
يأتي Google Pub/Sub في نسختين: النسخة القياسية، المعروفة ببساطة باسم Google Pub/Sub، والنسخة الخفيفة (lite) التي تكلّف أقل لكنها توفّر إتاحية أقل ومجموعة ميزات أقل. يمكن لـ Pub/Sub Lite مثلًا أن يعمل في منطقة (zone) واحدة – وهذا يخفّض التكلفة لكنه يعني أن بياناتك تُنسخ داخل تلك المنطقة فقط، بينما يضمن Pub/Sub القياسي النسخ المتزامن إلى منطقتين على الأقل إضافةً إلى نسخ بأفضل جهد إلى منطقة ثالثة.
إعداد Google Pub/Sub
تدير Google Pub/Sub من وحدة تحكم GCP على الويب إلى جانب كل خدمات GCP الأخرى، وهذا مريح للغاية.
إنشاء موضوع (topic)
الخيارات المتاحة عند إنشاء موضوع قليلة عادةً: فبالإضافة إلى تسميته (بالطبع)، يمكنك أن تختار إنشاء اشتراك افتراضي، وتحديد مخطط (schema) لرسائلك (تنشئه بشكل منفصل)، وضبط ترميز الرسائل واختيار مدة الاحتفاظ. وفي العمل اليومي المعتاد يكفي اختيار اسم.
نصيحة سريعة: قبل إنشاء المواضيع لتطبيق إنتاجي، خصّص 5 دقائق مع فريقك للاتفاق على اصطلاحات التسمية التي ستُطبَّق على نظام Pub/Sub كله، بحيث تُسمّى المواضيع والاشتراكات فيها بشكل متسق – فهذا يعود بفائدة كبيرة عندما تضطر إلى العثور على موارد Pub/Sub بين مئات المواضيع والاشتراكات.
إنشاء اشتراك (subscription)
بعد أن تصبح المواضيع التي سترسل إليها الرسائل موجودة، تكون الخطوة التالية إنشاء الاشتراكات، التي تحتفظ بالبيانات على بنية Google التحتية إلى أن تُسلَّم إلى خدماتك. تأتي الاشتراكات بمجموعة أغنى بكثير من خيارات الضبط (يمكنك حتى دفع الرسائل مباشرة إلى Google BigQuery)؛ ولن نغطيها كلها، بل الأساسية فقط.
أهم النقاط التي ينبغي التفكير فيها عند إعداد اشتراك:
- كم من الوقت يُتوقع أن تنتظر رسائلك قبل معالجتها، أو الأهم من ذلك، كم سيمضي قبل أن يُقَرّ باستلامها (acknowledged) – وهذا يحدد مدة الاحتفاظ بالرسائل التي عليك ضبطها (7 أيام افتراضيًا)
- كم من الوقت يحتاجه المشترك لمعالجة رسالة – القيمة الافتراضية 10 ثوانٍ، وإذا لم يتلقَّ Pub/Sub إقرارًا (ack) أو رفضًا (nack) خلال تلك المهلة، تُسلَّم الرسالة مرة أخرى (ربما إلى نسخة أخرى من المشترك).
- سياسة إعادة المحاولة – هل ينبغي أن يعيد Pub/Sub إرسال رسائلك فورًا أم بتأخير تراجع أُسّي (exponential backoff) (أنصح بالخيار الثاني، لأنه يمنح الخدمات التي تعمل كمشتركين بعض الوقت للتعافي بعد الفشل)
- Dead Lettering – يُنصح به بشدة لكل اشتراك – فالرسالة التي لا يمكن معالجتها (مثلًا لأن المشترك لا يستطيع تحليلها) لن تُعاد مرارًا وتكرارًا مستهلكةً موارد خدمة المشترك، ولن تضيع كذلك عند انتهاء مدة الاحتفاظ.
نصيحة سريعة: عند إعداد الاشتراكات، يستحق الأمر استخدام خدمة GCP أخرى هي Alerting. يمكن للتنبيهات أن تنطلق كلما وصلت رسائل جديدة إلى اشتراكات dead letter أو عندما يتجاوز عمر الرسائل في اشتراكاتك حدًا معينًا – وبهذه الطريقة ستعرف عندما يتأخر المشتركون أو عندما يحدث خطأ ما.
أدوات مفيدة
إلى جانب التنبيهات المذكورة أعلاه، تتيح لك مجموعة من المقاييس المتاحة مراقبة اشتراكاتك:

يمكنك أيضًا سحب عيّنة من الرسائل من اشتراكاتك، دون الإقرار بها، لفحص محتواها.
العمل مع Google Pub/Sub في Scala
تقدّم Google فعلًا مكتبات ربط لكل خدماتها (ومنها Pub/Sub)، إضافةً إلى Java SDK https://cloud.google.com/pubsub/docs/reference/libraries، لكن إن كنت تعمل بـ Scala مع أنواع التأثيرات (effect types)، فهناك مكتبة أنيقة بنتها permutive-engineering باسم fs2-google-pubsub تتيح لك العمل مع PubSub عبر تدفقات Fs2.
يمكن استخدام المكتبة بطريقتين: إما عبر نسخة Google Grpc أو عبر Http مع Http4s وبروتوكول REST. تصف صفحة المكتبة على GitHub كل الفروقات والمزايا والعيوب لكل منهما، لذا لن أكررها هنا. يعتمد مشروعنا التجريبي على نسخة Http4s، وهي وظيفية بالكامل ومستقرة.
مشروع تجريبي
لإظهار العمليات الأساسية مع Scala وPub/Sub، جمعتُ مشروعًا بسيطًا يعتمد على Http4s.
يتألف التدفق الأساسي من استقبال كائن Order عبر طلب HTTP Post وتمريره إلى موضوع Google Pub/Sub لدينا. وتواصل خدمة منفصلة باسم OrderService استقبال كل رسائل Order التي تظهر على أحد الاشتراكات في موضوع الطلبات. وهذا يسهّل رؤية كيفية التعامل مع جانبي الناشر والمشترك في مشاريعك بـ Scala.

خطوتنا الأولى هي التصريح بالمواضيع والاشتراكات التي أُنشئت في Pub/Sub عبر وحدة تحكم GCP، مع مسار ملف المفتاح الخاص بك، الذي يجب توليده مسبقًا للتواصل مع نسخة Google Pub/Sub لديك.
application.conf
http {
host = "localhost"
host = ${?HOSTNAME}
port = 8089
port = ${?PORT}
}
pub-sub {
project-id = "some-project-id"
project-id = ${?PROJECT_ID}
host = "pubsub.googleapis.com"
port = "443"
key-file-location = "/var/secrets/googlepubsub/key.json"
key-file-location = ${?PUB_SUB_KEY_FILE_LOCATION}
subscriptions {
orders = "orders-dev-sub"
orders = ${?ORDERS_SUBSCRIPTION}
}
topics {
orders = "orders-dev"
topic = ${?ORDERS_TOPIC}
}
}
الـ OrderEvent المتداول في كود Scala لدينا هو case class بسيط بعدة حقول، مع بعض أدوات فك الترميز والترميز الضمنية (implicit) الإضافية.
OrderEvent
import com.permutive.pubsub.consumer.decoder.MessageDecoder
import com.permutive.pubsub.producer.encoder.MessageEncoder
import core.pubsub.CirceImplicits.{pubSubDecoder, pubSubEncoder}
import io.circe.{Decoder, Encoder}
import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
case class OrderEvent(id: String, name: String, price: Double)
object OrderEvent {
implicit val orderDecoder: Decoder[OrderEvent] =
deriveDecoder[OrderEvent]
implicit val orderEncoder: Encoder[OrderEvent] =
deriveEncoder[OrderEvent]
implicit lazy val pubSubMsgEncoder: MessageEncoder[OrderEvent] = pubSubEncoder[OrderEvent]
implicit lazy val pubSubMsgDecoder: MessageDecoder[OrderEvent] = pubSubDecoder[OrderEvent]
}
لنشر الرسائل إلى Pub/Sub، أخفينا إنشاء المنتِج خلف ما يشبه المصنع (factory)، مما يتيح لك بناء أي عدد من المنتِجين لا يختلفون إلا في اسم الموضوع.
import cats.effect.IO
import cats.effect.kernel.Resource
import cats.implicits.catsSyntaxOptionId
import com.permutive.pubsub.producer.{Model, PubsubProducer}
import com.permutive.pubsub.producer.encoder.MessageEncoder
import com.permutive.pubsub.producer.http.{HttpPubsubProducer, PubsubHttpProducerConfig}
import config.PubSubConfiguration
import org.http4s.client.Client
import org.typelevel.log4cats.Logger
private[pubsub] trait PubSubProducerFactory {
def createProducer[T: MessageEncoder](topicName: String): Resource[IO, PubsubProducer[IO, T]]
}
private[pubsub] class PubSubProducerFactoryImpl(
client: Client[IO],
config: PubSubConfiguration
)(implicit logger: Logger[IO]) extends PubSubProducerFactory {
def createProducer[T: MessageEncoder](topicName: String): Resource[IO, PubsubProducer[IO, T]] =
HttpPubsubProducer.resource[IO, T](
projectId = Model.ProjectId(config.projectId),
topic = Model.Topic(topicName),
googleServiceAccountPath = config.keyFileLocation.some,
config = PubsubHttpProducerConfig[IO](
host = config.host,
port = config.port,
isEmulator = false,
onTokenRefreshError = e => logger.error(s"Producer $topicName error - Token refresh error: $e"),
onTokenRetriesExhausted = e =>
logger.error(
s"Producer $topicName error - Token retries exhausted error: $e"
)
),
client
)
}
على جانب المشترك، يدخل صنفان في العمل؛ الأول، PubSubSubscriber، يُهيَّأ باسم اشتراكك:
إعداد المشترك
def subscribe(subscriptionName: String): fs2.Stream[IO, ConsumerRecord[IO, T]] =
PubsubHttpConsumer.subscribe[IO, T](
projectId = ProjectId(config.projectId),
subscription = Subscription(subscriptionName),
serviceAccountPath = Some(config.keyFileLocation),
config = PubsubHttpConsumerConfig[IO](
host = config.host,
port = config.port,
isEmulator = false,
onTokenRefreshError = e =>
logger.error(
s"Subscriber $subscriptionName error - Token refresh error: $e"
),
onTokenRetriesExhausted = e =>
logger.error(
s"Subscriber $subscriptionName error - Token retries exhausted error: $e"
)
),
client,
(msg, err, _, nack) =>
logger.error(
s"Got error: $err from subscription: $subscriptionName on message: ${msg.messageId}"
) *> nack
)
والثاني يعكس منتِجينا: مصنع مستهلكين يبني مستهلكيك فوق المشترك الموصوف أعلاه.
مصنع المستهلكين
import cats.effect.IO
import cats.implicits.catsSyntaxApply
import com.permutive.pubsub.consumer.decoder.MessageDecoder
import config.PubSubConfiguration
import org.http4s.client.Client
import org.typelevel.log4cats.Logger
class PubSubConsumer[T: MessageDecoder] private[pubsub] (
pubSubSubscriber: PubSubSubscriber[T],
subscriptionName: String
)(implicit logger: Logger[IO]) {
def consumePubSubMessages(consumptionRecipe: T => IO[Boolean]): fs2.Stream[IO, Unit] = {
fs2.Stream.eval(logger.info(s"Running $subscriptionName consumer")) *>
pubSubSubscriber
.subscribe(subscriptionName)
.evalMap(
msg =>
consumptionRecipe(msg.value).flatMap(
isSuccessful =>
if (isSuccessful) msg.ack
else msg.nack
)
)
}
}
object PubSubConsumer {
def create[T: MessageDecoder](client: Client[IO], subscriptionName: String, config: PubSubConfiguration)(
implicit logger: Logger[IO]
): PubSubConsumer[T] =
new PubSubConsumer[T](
pubSubSubscriber = new PubSubSubscriberImpl[T](client = client, config = config),
subscriptionName = subscriptionName
)
}
لاستهلاك الرسائل الواردة وجعلها مرئية، كتبتُ خدمة بسيطة جدًا تكتفي بتسجيلها في السجل:
OrderService
class OrderService()(implicit logger: Logger[IO]) {
def consumeOrder(msg: OrderEvent): IO[Boolean] = {
logger.info(s"Consuming order: $msg") *> IO.pure(true)
}
}
الاستخدام
إنشاء منتِج لا يتطلب سوى تمرير مرجع إلى عميل http والإعدادات:
إنشاء المنتِج
class PubSubModule(client: Client[IO], pubSubConfiguration: PubSubConfiguration)(implicit logger: Logger[IO]) {
lazy val pusSubProducerFactory = new PubSubProducerFactoryImpl(client, pubSubConfiguration)
lazy val orderProducer: Resource[IO, PubsubProducer[IO, OrderEvent]] =
pusSubProducerFactory.createProducer[OrderEvent](pubSubConfiguration.topics.orders)
}
يُربط جانب المستهلك في دالة Main لدينا، حيث نحدد أيضًا الخدمة المسؤولة عن معالجة الرسائل الواردة:
تهيئة المستهلكين
override def run(args: List[String]): IO[ExitCode] = {
//resource modules
lazy val infrastructureResourceModule = new InfrastructureResourceModule(config)
val programStream =
for {
//modules
....................
//routes
....................
//server initialization
_ <- BlazeServerBuilder[IO]
.bindHttp(config.http.port, config.http.host)
.withHttpApp(
(http4sInterpreter.toRoutes(endpoints.asInstanceOf[List[ServerEndpoint[Fs2Streams[IO], IO]]]) <+>
http4sInterpreter.toRoutes(swaggerEndpoints)).orNotFound
)
.serve
.concurrently {
//consumers initialization
coreModule.orderMessageConsumer
.consumePubSubMessages(
coreModule.orderService.consumeOrder
)
.void
}
} yield ()
programStream.compile.drain.as(ExitCode.Success)
}
مثال
تأكد من أن كل إعداد في application.conf مملوء، وشغّل المشروع بالأمر المعتاد sbt run، وافتح وثائق swagger المولَّدة تلقائيًا على http://localhost:8089/docs/ وأرسل رسالة إلى نقطة النهاية /api/create.
باستخدام Swagger:
يجب أن يستقبل OrderApi الرسالة ويسلّمها إلى المنتِج، الذي يمرّرها إلى Google Pub/Sub. ثم يوزّع Pub/Sub الرسالة على كل مشترك معرَّف للموضوع (واحد فقط في حالتنا). وما إن تصل الرسالة إلى اشتراكنا، يجب أن يلتقطها مشتركنا، وأن تعالجها OrderService.
الرسائل كما تظهر في وحدة تحكم GCP Pub/Sub:
مخرجات التطبيق أثناء التشغيل:
الخلاصة
يمكن أن يكون Google Pub/Sub إضافة قيّمة حقًا إلى صندوق أدواتك عند تصميم نظام قائم على الخدمات المصغّرة ومبني على الرسائل غير المتزامنة، خصوصًا إذا كنت تفضّل تفادي الجهد الإضافي لصيانة عنقود Rabbit أو كان Kafka أكبر من حاجتك. البدء بسيط، والمراقبة سهلة، ويمكنك أن تتلقى تنبيهًا كلما حدث خطأ ما. وشعبيته تواصل النمو مع ظهور مكتبات وأدوات أكثر كل عام، لذا يستحق على الأقل أن تلقي نظرة عليه عند تخطيط مشروعك القادم و/أو إن كنت تعتمد أصلًا على خدمات GCP أخرى.