Meer informatie over Ruby on Rails met Pub/Sub

Ruby on Rails (Rails, RoR) is een bekend raamwerk voor webtoepassingen geschreven in het Ruby programmeertaal. Pub/Sub is een afkorting van software ontwerppatronen genaamd Publiceren-afmelden. Ik zal uitleggen hoe communicatie tussen software componenten in Rails kan worden afgehandeld door Pub/Sub.

Wat is Pub/sub?

Pub/sub is een software-ontwerppatroon dat voorziet in service-naar-service communicatie. Service
houdt een van de twee rollen in: uitgever (die produceert) of ontvanger (die consumeert). Wat is
geproduceerd om te worden geconsumeerd, wordt bepaald als een gebeurtenis, een bericht of een melding. In de
In de context van dit artikel worden ze door elkaar gebruikt om naar hetzelfde te verwijzen.
De dienst die produceert weet niet wie consumeert. De dienst die consumeert weet niet
de oorsprong van het bericht kennen. Ze kunnen onbekend blijven voor elkaar. Dit is anders dan
wachtrijen voor berichten, waarbij de component die het bericht verzendt vaak de bestemming kent
- Met deze manier van berichten versturen kun je overal berichten naartoe sturen. Dit mechanisme is een kern
van Pub/sub en het betekent dat ze ontkoppeld zijn.

Om hun wederzijdse belangen tot uitdrukking te brengen, moeten ze een gemeenschappelijk begrip delen. Daarom,
beide rollen hebben een impliciet mechanisme van de stok waarbij de producent van een bericht en de
consument van het bericht ontmoeten. Dit mechanisme wordt onderwerp, abonnement of topic genoemd. Het is
verantwoordelijk voor het categoriseren van berichten naar onderwerpen, het is in wezen een stateloos berichtfilter.
Onderwerpen fungeren als zendstations. Een uitgever stuurt het bericht naar het onderwerp,
abonnees ontvangen onmiddellijk het bericht van het onderwerp. Vanwege de ontkoppelde
diensten is de meest efficiënte manier om berichten uit te wisselen om ze asynchroon af te handelen.

Rails zonder Pub/Sub

Standaard is er geen Rails-overhead voor software-ontwerppatronen voor het doorgeven van berichten tussen componenten. Ontwikkelaars gebruiken standaard objectgeoriënteerd programmeren (OOP) paradigma: parameters doorgeven aan functies, klassen vragen over waarden.

Als de applicatie vrij ongecompliceerd is, kan dit voldoende zijn. Als de applicatie groeit, bijvoorbeeld, moeten sommige bewerkingen asynchroon worden uitgevoerd, dan is de project abstractie nodig die die gegevensworkflow oplost. In plaats van het wiel opnieuw uit te vinden, kunnen ontwikkelaars het volgende implementeren Pub/sub om dit gebrek aan abstractie op te vullen.

Voordelen van Pub/Sub met Rails

• Active Record Callbacks vermijden.
• Door asynchrone parallelle verwerking aan een systeem toe te voegen, worden de prestaties, betrouwbaarheid en schaalbaarheid verbeterd.
• Berichten kunnen asynchroon worden uitgezonden naar verschillende delen van het systeem.
• Hiermee kunnen berichten asynchroon worden uitgezonden naar verschillende delen van een systeem.
• Ontkoppeling - het toevoegen of wijzigen van een functionaliteit heeft geen invloed omdat Pub/Sub
  kun je aanpassen hoe alles op elkaar inwerkt.
• De berichtenconsument hoeft niet langer periodiek te controleren op updates of nieuwe
  informatie. Het vermindert de afleverlatentie die vooral problematisch kan zijn in systemen
  zonder tolerantie voor vertragingen.
• Er is geen limiet aan het aantal abonnees dat het systeem aankan, omdat het kan veranderen,
  upgraden, vermenigvuldigen of verdwijnen.

Nadelen van Pub/Sub met Rails

• Het grote nadeel van Pub/Sub systemen is de ontkoppeling van uitgever en
  abonnee.

Rails Pub/Sub invoeren

Voorbeelden van broncode in Rails is geschreven met behulp van bibliotheek
Pub/Sub op Rails (in de nomenclatuur van Ruby wordt een bibliotheek gem genoemd): Meer details vind je in de readme van de gem. De implementatie bestaat uit modules:

1. Domein,
2. Evenement,
3. Gebeurtenis handler,
4. Uitgever,
5. Inschrijving.

Domein

Beschrijft bedrijfslogica om Pub/Sub van context te voorzien en daardoor schoon te maken code.

 module Meldingen
   uitbreiden PubSub::Domein
 einde

 module Rapporten
   uitbreiden PubSub::Domein
 einde

Evenement

Het is een klasse die beschrijft wat er is gebeurd. Declareer de classnaam zo zelfbeschrijvend mogelijk met wat er is gebeurd, bijvoorbeeld: geannuleerd, gewijzigd, aangemaakt, vernietigd, verzonden, bijgewerkt. Namen van gebeurtenissen kunnen er als volgt uitzien: ProfitAndLossStatementCreatedEvent, wat betekent dat er een financieel overzicht is aangemaakt.

 klasse Reports::ProfitAndLossStatementCreatedEvent < PubSub::DomainEvent
   attribuut :profit_and_loss_statement_id, Types::Strict::Integer
 einde

Evenement uitgever

Klasse die gebeurtenissen kan uitzenden. Het voorbeeld toont het maken van een servicerapport. Als het rapport met succes is gemaakt, wordt de gebeurtenis voor het maken van dat rapport uitgezonden.

klasse rapporten::winst-en-verliesrekening service
   include PubSub::Emit
    def uitvoeren
     emit(:report_profit_and_loss_statement_created, profit_and_loss_statement_id: id) if result.ok?
   einde
 einde

Gebeurtenis handler

Deze klasse moet worden uitgevoerd als reactie op het afhandelen van een gebeurtenis.

module Meldingen
 Klasse ReportsProfitAndLossStatementCreatedHandler < PubSub::DomainEventHandler
   def oproep
     ReportMailer.profit_and_loss_statement(profit_and_loss_statement).deliver_now
   einde

   privé

   def winst_en_verlies_statement
     ProfitAndLossStatement.find(event_data.profit_and_loss_statement_id)
   einde
 einde
einde

Abonnement

Gebeurtenissen zijn gebonden aan hun afhandelaars door middel van abonnementen.

meldingen:
 reports__profit_and_loss_statement_created: async

Voorbeeldgebruiksgevallen:

• "Volgfunctie in sociale netwerken,
• Internet der dingen,
• Mailing,
• Melding over gegenereerde bestanden.

Vergelijkbare patronen

1. EventBus - Componenten kunnen gebeurtenissen naar EventBus sturen zonder te weten wie ze zal oppikken of hoeveel respondenten zullen reageren,
2. Waarnemer - het subject onderhoudt een lijst van afhankelijke personen, waarnemers genaamd, en stelt ze op de hoogte wanneer hun toestand verandert,
3. Pooling - Bij polling vragen clients periodiek aan het systeem of er nieuwe gebeurtenissen of gegevens zijn.

Juwelen

• https://github.com/edisonywh/rocketman

• https://github.com/krisleech/wisper

• https://github.com/stevo/pubsuboprails

Samenvatting

Pub/sub is geen gebruikelijke aanpak in Ruby in Rails. Zoals geïntroduceerd in het artikel, kan dit patroon veel voordelen opleveren voor het project - het kan de code schoon maken, services ontkoppelen en ze gemakkelijk schaalbaar maken.