In de echte wereld gebeuren er dingen, en daar reageren we op, hetzelfde gebeurt in elk bedrijf, gebeurtenissen zijn wat ze draaiende houdt, of het nu gaat om een verkoop, een klantnavraag, een kwaadaardige poging om uw site te kraken of een fout in een van uw LOB-applicaties. Net als in de echte wereld, moet uw bedrijf op deze gebeurtenissen reageren, niet allemaal hebben dezelfde prioriteit of zijn even belangrijk voor hetzelfde publiek binnen uw bedrijf.

Hoewel de laatste paragraaf voor de meeste mensen misschien voor de hand liggend klinkt, hebben de meeste architecturen waarop bedrijven draaien niet de mogelijkheid om deze gebeurtenissen te delen met alle partijen die er belang bij hebben. Gebeurtenissen worden afgehandeld door de applicaties van een bepaald domein, bijvoorbeeld een verkoop wordt afgehandeld door de POS-applicatie, een factuur of een Bon wordt gegenereerd door die of een andere applicatie van hetzelfde domein, maar als u uw onderhoudsafdeling wilt informeren dat er een ander product is verkocht waar zij zich bewust van moeten zijn, zal dit plaatsvinden in een batchproces 's nachts en pas morgen voor hen beschikbaar zijn. Als uw marketingafdeling wil weten welke klanten een bepaald product hebben gekocht om een nieuwe campagne te creëren, zal zij iemand van de verkoopafdeling vragen die iemand van de IT-afdeling zal vragen om een query uit te voeren en een rapport met die informatie te verkrijgen.

Dat is de schoonheid van gebeurtenisgestuurde architecturen, je produceert een gebeurtenis en iedereen die er interesse in heeft, krijgt de gelegenheid om erop te reageren.

Dus, wat is een Event-driven Architectuur?

Event-driven architectuur is een ontwerppatroon waarbij verschillende, ontkoppelde applicaties asynchroon events publiceren naar een event broker waarop kan worden ingeschreven en waarvan kan worden geconsumeerd. Zodra een event is verzonden, kan elke applicatie die toegang heeft tot dat eventtype erop reageren. De applicatie die het event heeft verzonden, hoeft niet te weten welke andere applicaties dat event zullen consumeren. Het omgekeerde is ook waar, een consument hoeft niet te weten waar een event vandaan komt.

Hoe gebeurtenisgestuurde architecturen werken

Op een simpele manier zijn er event producers en event consumers, en er zijn twee veelvoorkomende manieren om met de events om te gaan:

• Pub/Sub – Waarbij de producers van gebeurtenissen uitgevers zijn, en wanneer zij een gebeurtenis publiceren, komt deze beschikbaar voor alle consumenten die zich hebben ingeschreven als abonnees voor dat gebeurtenistype. Als een nieuwe abonnee zich inschrijft, heeft deze alleen toegang tot nieuwe gebeurtenissen die na de inschrijving zijn gepubliceerd.
• Event Streaming – Alle geproduceerde gebeurtenissen worden opgeslagen in een logboek, geordend, en elke consument die toegang heeft tot de stream kan alle gebeurtenissen lezen en is verantwoordelijk voor het bijhouden van welke gebeurtenissen al werden geconsumeerd. Op deze manier kan een nieuwe consument gebeurtenissen uit het verleden opnieuw afspelen die zijn gemaakt voordat deze toegang had tot de stream.

In beide gevallen eindigt de verantwoordelijkheid van de producent op het moment dat deze het evenement aan de event broker levert. De producent weet niet wie het zal consumeren, en de bedrijfslogica kan niet afhankelijk zijn van de aanname dat een bepaalde consument zal luisteren om het te consumeren.

Wanneer gebruik je een event-driven architectuur?

Er zijn enkele belangrijke scenario's waarin dit soort architectuur van cruciaal belang is:

• Microservices: Event-driven architecture is bijzonder geschikt voor systemen gebaseerd op microservices, omdat het verschillende services in staat stelt om asynchroon met elkaar te communiceren en te reageren op veranderingen in andere services.
• Realtime-analyse: Met event-driven architecture is het mogelijk om datastromen met een hoog volume in bijna realtime te verwerken, wat nuttig is voor toepassingen zoals realtime fraudeopsporing, realtime tracking van klantgedrag en realtime voorraadbeheer.
• IoT: IoT-systemen genereren enorme hoeveelheden sensordata die kunnen worden ingevoerd in een gebeurtenisgestuurde architectuur voor realtime verwerking en monitoring.
• Bedrijfsprocesautomatisering: Op gebeurtenissen gebaseerde architecturen kunnen worden gebruikt om bedrijfsprocessen te automatiseren die meerdere systemen omvatten, zoals orderverwerking, facturatie en voorraadbeheer.
• Realtime monitoring: Door gebruik te maken van event-driven architectuur is het mogelijk om verschillende delen van de systemen te monitoren en realtime alerts of andere acties te activeren.
• Mobiele-app-backends: Een gebeurtenisgestuurde architectuur kan nuttig zijn bij het bouwen van mobiele-app-backends omdat het verschillende delen van het systeem in realtime laat reageren op gebeurtenissen, zoals pushmeldingen, locatie-updates of wijzigingen in gebruikersgegevens.

Over het algemeen passen gebeurtenisgestuurde architecturen uitstekend bij use cases die real-time verwerking, schaalbaarheid en flexibiliteit vereisen. Het kan verschillende teams helpen om parallel te werken en met ontkoppelde services.

Dat betekent niet dat het alleen zinvol is in deze scenario's, en zelfs als je op dit moment een van deze scenario's niet hebt, zal het eerder gebeuren dan je denkt als je je bedrijf wilt laten groeien. En dan heb je een reeks potentiële voordelen die je helpen sneller te reageren op veranderende bedrijfsomstandigheden en om toenemend verkeer en datacapaciteit te verwerken naarmate ze schalen. Ze kunnen helpen de algehele prestaties van het systeem te verbeteren, de samenwerking te verbeteren en het ontwikkelingsproces soepeler te laten verlopen.

Als het fantastisch is, waarom gebruikt niet elk bedrijf het?

Nou, er zijn enkele uitdagingen die overwonnen moeten worden bij het gebruik van gebeurtenisgestuurde architecturen:

• Schema beheer van gebeurtenissen: Met een gedistribueerde op gebeurtenissen gebaseerde architectuur kan het een uitdaging zijn om consistentie en compatibiliteit te handhaven in de structuur van de gebeurtenissen die worden geproduceerd en geconsumeerd tussen verschillende systemen.
• Versiebeheer van gebeurtenissen: Wanneer de producent van de gebeurtenis zijn schema wijzigt, moeten de consumenten van de gebeurtenis dienovereenkomstig worden bijgewerkt. In een grootschalig systeem wordt dit erg uitdagend.
• Testen: Vanwege de gedistribueerde aard van gebeurtenisgestuurde architecturen kan het moeilijk zijn om het algehele gedrag van het systeem te testen en te valideren, vooral bij real-time gebeurtenissen.
• Beveiliging: Naarmate gebeurtenissen door meerdere systemen stromen, kan het moeilijk zijn om ervoor te zorgen dat ze goed beveiligd zijn tegen ongeautoriseerde toegang of manipulatie.
• Latentie: Als de tijd die nodig is om een gebeurtenis te leveren en te verwerken te hoog is, kan het een uitdaging zijn om real-time applicaties te implementeren.
• Schaalbaarheid: Naarmate het aantal gebeurtenissen toeneemt, kan het een uitdaging zijn om een op gebeurtenissen gebaseerde architectuur op te schalen om de toegenomen belasting te verwerken.
• Idempotentie en gebeurtenisvolgorde: In een op gebeurtenissen gebaseerde architectuur kunnen gebeurtenissen meerdere keren worden afgeleverd. Zorgen dat dezelfde gebeurtenis niet meerdere keren wordt verwerkt, kan een lastige taak zijn.
• Foutopsporing: Wanneer dingen misgaan in een event-driven architectuur, kan het lastig zijn om de hoofdoorzaak van het probleem te achterhalen en op te lossen.

Hoewel deze uitdagingen ontmoedigend kunnen lijken, kunnen veel moderne tools, frameworks en bibliotheken helpen om sommige van deze problemen te verminderen en gebeurtenisgestuurde architecturen gemakkelijker te implementeren en te onderhouden.

Zijn er hulpmiddelen die me kunnen helpen dit te benutten?

Ja, tegenwoordig zijn er verschillende tools die je helpen een event-gedreven architectuur te implementeren. Deze lijst is niet uitputtend, maar bevat enkele van de meer gangbare tools:

• Apache Kafka: Een open-source event streaming platform dat grote aantallen events kan verwerken en hoge doorvoer aankan.
• RabbitMQ: Een open-source message broker die gebruikt kan worden om pub/sub of event streaming architecturen te implementeren.
• Apache Pulsar: Een gedistribueerd pub-sub berichtensysteem dat meerdere berichtmodellen ondersteunt, waaronder event streaming.
• Apache Storm: Een gedistribueerd realtime rekensysteem dat gebruikt kan worden om datastromen in realtime te verwerken.
• AWS Kinesis: Een beheerde service aangeboden door Amazon Web Services voor realtime verwerking van streaminggegevens.
• Azure Event Grid: Een beheerde service geleverd door Microsoft Azure voor het routeren en verwerken van gebeurtenissen.
• Google Cloud Pub/Sub: Een beheerde service die door Google Cloud wordt aangeboden voor real-time messaging en event streaming.
• Apache NiFi: Een open-source tool voor gegevensintegratie en realtime gegevensverwerking.
• Apache Flink: Een open-source stream processing framework voor gedistribueerde streaming data applicaties.
• Apache Samza: Een stream processing framework, ontworpen voor het verwerken van grote hoeveelheden gebeurtenissen en het afhandelen van hoge doorvoer.
• Confluent: Een populair platform voor event streaming dat gebouwd is bovenop Apache Kafka. Het bevat extra functionaliteiten en mogelijkheden zoals een schema registry, REST proxy en een SQL query engine voor Kafka.

Het is belangrijk te vermelden dat, afhankelijk van uw gebruikssituatie, bepaalde tools geschikter kunnen zijn dan andere, en dat verschillende tools verschillende functies en mogelijkheden kunnen hebben.

Concluderend stellen we dat gebeurtenisgestuurde architecturen bedrijven in staat stellen om flexibel en schaalbaar te reageren op gebeurtenissen, waardoor ze sneller kunnen inspelen op veranderende zakelijke behoeften en kansen. Door de producenten en consumenten van gebeurtenissen te ontkoppelen, kunnen bedrijven grotere flexibiliteit en veerkracht behouden, en het risico vermijden dat ze worden vertraagd door monolithische systemen die moeilijk te wijzigen zijn. Hoewel de implementatie van gebeurtenisgestuurde architecturen uitdagend kan zijn, maken de voordelen van verhoogde snelheid, flexibiliteit en schaalbaarheid het een waardevolle overweging voor elk bedrijf dat wil groeien en gedijen in de huidige snelle, competitieve omgeving.

António Rodrigues CTO