Գնահատել նախագիծը
← Բոլոր հրապարակումները

Pub/Sub-ի օգտագործումը Scala-ից

Միկրոսերվիսային համակարգերում (և ոչ միայն) հաճախ անհրաժեշտ է, որ սերվիսները միմյանց հետ խոսեն ասինխրոն՝ որևէ հաղորդագրությունների շերտի միջոցով։ Google Pub/Sub-ը, որը Google-ն առաջարկում է անմիջապես GCP-ի ներսում, հարմար տարբերակ է. այն Kafka-ից պակաս բարդ է, բայց օգտագործելը պարզ է և սպասարկում չի պահանջում։

8 րոպե
ScalaՄիկրոսերվիսներApache KafkaGCPGoogle PubSub

Ի՞նչ է Pub/Sub-ը

Միկրոսերվիսային ճարտարապետությունները (թեև ոչ միայն դրանք) շատ հաճախ պահանջում են սերվիսների միջև ասինխրոն հաղորդակցություն՝ կառուցված որևէ հաղորդագրությունների լուծման վրա։ Այդ փուլում ընտրության հնարավորություններն առատ են՝ մեկ հանգույցով RabbitMQ-ից մինչև լիարժեք բազմահանգույց Kafka կլաստեր։ Google Pub/Sub-ը Google-ի մոտեցումն է ասինխրոն հաղորդակցության հարցում, որը հասանելի է հենց Google-ի GCP-ի ներսում. այն Kafka-ից պակաս առաջադեմ է, բայց դրա փոխարեն պարզ է օգտագործելու համար և սպասարկում չի պահանջում։

Pub/Sub-ը թույլ է տալիս ձեր իրադարձությունների համար կառուցել արտադրողների (producers) և սպառողների (consumers) համակարգ։ Արտադրողները իրադարձությունները ուղարկում են Pub/Sub սերվիս՝ առանց իմանալու, թե երբ կամ ինչպես դրանք կմշակվեն, իսկ Pub/Sub սերվիսն այնուհետև փորձում է այդ հաղորդագրություններից յուրաքանչյուրը հասցնել նախապես սահմանված բաժանորդներին (subscribers)։

Google Pub/Sub-ը երկու տարբերակով է. ստանդարտը՝ պարզապես Google Pub/Sub անունով, և թեթևը (lite), որն ավելի էժան է, բայց ունի ավելի ցածր հասանելիություն և կրճատ հնարավորություններ։ Pub/Sub Lite-ը, օրինակ, կարող է աշխատել մեկ գոտում (zone). դա նվազեցնում է արժեքը, բայց նշանակում է, որ ձեր տվյալները կրկնօրինակվում են միայն այդ գոտու ներսում, մինչդեռ ստանդարտ Pub/Sub-ը երաշխավորում է սինխրոն կրկնօրինակում առնվազն երկու գոտիներում՝ գումարած հնարավորինս կրկնօրինակում երրորդում։

Google Pub/Sub-ի կարգավորումը

Google Pub/Sub-ը կառավարվում է GCP-ի վեբ կոնսոլում՝ GCP-ի մյուս բոլոր սերվիսների կողքին, ինչը շատ հարմար է։

Թոփիքի ստեղծումը

Թոփիք ստեղծելիս ընտրությունները սովորաբար քիչ են. անունից բացի (իհարկե) կարելի է որոշել՝ ստեղծվի արդյոք լռելյայն բաժանորդագրություն, սահմանել հաղորդագրությունների սխեմա (որը ստեղծվում է առանձին), նշել հաղորդագրությունների կոդավորումը և ընտրել պահպանման տևողությունը։ Սովորական ամենօրյա աշխատանքի համար բավական է անուն ընտրելը։

Արագ խորհուրդ. Նախքան արտադրական հավելվածի համար թոփիքներ ստեղծելը 5 րոպե տրամադրեք թիմի հետ՝ համաձայնեցնելու անվանման կանոնները, որոնք կկիրառվեն ամբողջ Pub/Sub համակարգում, որպեսզի թոփիքներն ու դրանց բաժանորդագրությունները անվանվեն միատեսակ. սա հսկայական օգուտ է տալիս, երբ հարյուրավոր թոփիքների ու բաժանորդագրությունների մեջ պետք է գտնել Pub/Sub ռեսուրսներ։

Բաժանորդագրության ստեղծումը

Երբ այն թոփիք(ներ)ը, որոնց հաղորդագրություններ եք ուղարկելու, արդեն կան, հաջորդ քայլը բաժանորդագրություններ ստեղծելն է, որոնք տվյալները պահում են Google-ի ենթակառուցվածքում, մինչև դրանք հասցվեն ձեր սերվիսներին։ Բաժանորդագրություններն ունեն կարգավորումների շատ ավելի հարուստ շարք (կարելի է նույնիսկ հաղորդագրությունները անմիջապես ուղարկել Google BigQuery). մենք բոլորը չենք քննարկի, միայն հիմնականները։

Բաժանորդագրություն կարգավորելիս հիմնական կետերը, որոնց մասին պետք է մտածել, հետևյալն են.

  • Որքան ժամանակ են ձեր հաղորդագրությունները սպասվում մշակման կամ, ավելի կարևոր, որքան ժամանակ կանցնի մինչև դրանց հաստատումը (acknowledgement). սա որոշում է հաղորդագրությունների պահպանման այն տևողությունը, որը պետք է սահմանեք (լռելյայն՝ 7 օր)
  • Որքան ժամանակ է պետք բաժանորդին հաղորդագրությունը մշակելու համար. լռելյայն՝ 10 վայրկյան, և եթե Pub/Sub-ը այդ ընթացքում ack կամ nack չստանա, հաղորդագրությունը նորից է հասցվում (հնարավոր է՝ բաժանորդի մեկ այլ օրինակի)։
  • Կրկնության քաղաքականություն (retry policy). արդյոք Pub/Sub-ը պետք է ձեր հաղորդագրությունները նորից ուղարկի անմիջապես, թե էքսպոնենցիալ հետաձգմամբ (backoff) (ես կառաջարկեի երկրորդը, քանի որ դա բաժանորդի դերում հանդես եկող սերվիսներին ժամանակ է տալիս ձախողումից հետո վերականգնվելու)
  • Dead Lettering – խստորեն խորհուրդ է տրվում յուրաքանչյուր բաժանորդագրության համար. հաղորդագրությունը, որը հնարավոր չէ մշակել (օրինակ՝ բաժանորդը չի կարողանում այն վերլուծել), այդ դեպքում ո՛չ կրկին ու կրկին կուղարկվի՝ սպառելով ձեր բաժանորդ սերվիսի ռեսուրսները, ո՛չ էլ կկորչի պահպանման ժամկետի ավարտին։

Արագ խորհուրդ. Բաժանորդագրություններ կարգավորելիս արժե օգտագործել GCP-ի մեկ այլ սերվիս՝ հատկապես Alerting-ը։ Ահազանգերը կարող են գործարկվել, երբ dead letter բաժանորդագրություններում նոր հաղորդագրություններ են հայտնվում կամ երբ ձեր բաժանորդագրությունների հաղորդագրությունները որոշակի տարիքը գերազանցում են. այդպես կտեղեկանաք, երբ ձեր բաժանորդները հետ են մնում կամ ինչ-որ բան այն չէ։

Օգտակար գործիքներ

Վերը նշված ահազանգերից բացի, հասանելի մետրիկաների շարքը թույլ է տալիս հետևել ձեր բաժանորդագրություններին.

մետրիկաներ

Կարող եք նաև ձեր բաժանորդագրություններից հաղորդագրությունների նմուշ քաշել՝ առանց դրանք հաստատելու, որպեսզի տեսնեք, թե ինչ են դրանք պարունակում։

Google Pub/Sub-ի հետ աշխատանքը Scala-ում

Google-ն իսկապես տրամադրում է իր բոլոր սերվիսների (այդ թվում՝ Pub/Sub-ի) համար կապակցումներ (bindings), ինչպես նաև Java SDK https://cloud.google.com/pubsub/docs/reference/libraries, բայց եթե Scala-ում աշխատում եք effect տիպերով, կա հարմար գրադարան, որը ստեղծել է permutive-engineering-ը՝ fs2-google-pubsub անունով, որը թույլ է տալիս PubSub-ի հետ աշխատել Fs2 հոսքերի միջոցով։

Գրադարանը կարելի է օգտագործել երկու եղանակով. կամ Google Grpc տարբերակով, կամ Http-ով՝ Http4s-ի և REST արձանագրության միջոցով։ Գրադարանի GitHub էջը նկարագրում է յուրաքանչյուրի բոլոր տարբերությունները, առավելություններն ու թերությունները, այնպես որ այստեղ դրանք չեմ կրկնի։ Մեր օրինակելի նախագիծը հիմնվում է Http4s տարբերակի վրա, որն ամբողջովին աշխատունակ է և կայուն։

Օրինակելի նախագիծ

Scala-ով և Pub/Sub-ով հիմնական գործողությունները ցույց տալու համար ես պատրաստել եմ Http4s-ի վրա հիմնված պարզ նախագիծ։

Հիմնական հոսքը բաղկացած է HTTP Post հարցումով Order օբյեկտ ընդունելուց և այն մեր Google Pub/Sub թոփիք ուղարկելուց։ OrderService անունով առանձին սերվիսը շարունակաբար ստանում է բոլոր Order հաղորդագրությունները, որոնք հայտնվում են order թոփիքի բաժանորդագրություններից մեկում։ Սա հեշտացնում է տեսնելը, թե ինչպես աշխատել և՛ հրատարակողի, և՛ բաժանորդի կողմերի հետ ձեր Scala նախագծերում։

api

Մեր առաջին քայլը 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}
    }
}

Մեր Scala կոդում շրջանառվող OrderEvent-ը պարզ 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-ը, սկզբնավորվում է ձեր բաժանորդագրության անունով.

Subscriber setup

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
    )

Երկրորդը արտացոլում է մեր արտադրողներին. սա սպառողների factory է, որը ձեր սպառողներին կառուցում է վերը նկարագրված բաժանորդի վրա։

Consumer factory

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 client-ի հղումը և կոնֆիգուրացիան.

Create producer

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 մեթոդում, որտեղ նաև նշվում է, թե որ սերվիսն է պատասխանատու մուտքային հաղորդագրությունների մշակման համար.

Init consumers

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 endpoint-ին։

Swagger-ի օգտագործմամբ.

OrderApi-ն պետք է ստանա հաղորդագրությունը և փոխանցի արտադրողին, որն այն ուղարկում է Google Pub/Sub։ Այնուհետև Pub/Sub-ը հաղորդագրությունը բաշխում է թոփիքի համար սահմանված յուրաքանչյուր բաժանորդին (մեր դեպքում՝ ընդամենը մեկին)։ Հենց հաղորդագրությունը հայտնվի մեր բաժանորդագրության մեջ, մեր բաժանորդը պետք է այն վերցնի, իսկ OrderService-ը պետք է մշակի։

GCP Pub/Sub կոնսոլում երևացող հաղորդագրությունները.

Աշխատող հավելվածի արդյունքը.

Ամփոփում

Google Pub/Sub-ը կարող է իսկապես արժեքավոր հավելում լինել ձեր գործիքակազմում՝ ասինխրոն հաղորդագրությունների վրա հիմնված միկրոսերվիսային համակարգ նախագծելիս, հատկապես եթե նախընտրում եք խուսափել Rabbit կլաստերի սպասարկման լրացուցիչ ջանքերից կամ Kafka-ն ձեր կարիքների համար չափազանց ծանր կլիներ։ Սկսելը պարզ է, մոնիթորինգը՝ հեշտ, և կարող եք ահազանգ ստանալ, երբ ինչ-որ բան այն չէ։ Դրա ժողովրդականությունը շարունակում է աճել, քանի որ ամեն տարի ավելի շատ գրադարաններ ու գործիքներ են հայտնվում, այնպես որ այն արժանի է գոնե հայացքի ձեր հաջորդ նախագիծը պլանավորելիս և/կամ եթե արդեն օգտվում եք GCP-ի այլ սերվիսներից։