Phenquestions
Wanneer we message brokers willen integreren in onze applicatie, waardoor we gemakkelijk kunnen schalen en ons systeem asynchroon kunnen verbinden, zijn er veel message brokers die de lijst kunnen maken waaruit u er een kunt kiezen, zoals:
- KonijnMQ
- Apache Kafka
- ActiveMQ
- AWS SQS
- Redis
Elk van deze berichtenmakelaars heeft zijn eigen lijst met voor- en nadelen, maar de meest uitdagende opties zijn de eerste twee, RabbitMQ en Apache Kafka. In deze les zullen we punten opsommen die kunnen helpen om de beslissing om met de een boven de ander te gaan, te verfijnen. Ten slotte is het de moeite waard erop te wijzen dat geen van deze in alle gebruikssituaties beter is dan de andere en dat het volledig afhangt van wat u wilt bereiken, dus er is niet één juist antwoord!
We beginnen met een eenvoudige introductie van deze tools.
Apache Kafka
Zoals we in deze les al zeiden, is Apache Kafka een gedistribueerd, fouttolerant, horizontaal schaalbaar commit-logboek. Dit betekent dat Kafka een verdeel-en-heers-term heel goed kan uitvoeren, het kan uw gegevens repliceren om beschikbaarheid te garanderen en is zeer schaalbaar in die zin dat u tijdens runtime nieuwe servers kunt opnemen om de capaciteit te vergroten om meer berichten te beheren.
Kafka Producent en Consument
KonijnMQ
RabbitMQ is een meer algemene en eenvoudiger te gebruiken berichtenmakelaar die zelf bijhoudt welke berichten door de klant zijn geconsumeerd en de andere bewaart. Zelfs als de RabbitMQ-server om de een of andere reden uitvalt, kunt u er zeker van zijn dat de berichten die momenteel in de wachtrijen staan, op het bestandssysteem zijn opgeslagen, zodat wanneer RabbitMQ weer verschijnt, deze berichten op een consistente manier door consumenten kunnen worden verwerkt.
RabbitMQ werkt
Superkracht: Apache Kafka
De belangrijkste superkracht van Kafka is dat het kan worden gebruikt als een wachtrijsysteem, maar dat is niet beperkt tot. Kafka lijkt meer op een cirkelvormige buffer die net zo groot kan worden als een schijf op de machine op het cluster, en ons dus in staat stelt berichten opnieuw te lezen. Dit kan door de klant worden gedaan zonder afhankelijk te zijn van het Kafka-cluster, aangezien het volledig de verantwoordelijkheid van de klant is om de metagegevens van het bericht te noteren die het momenteel aan het lezen is en het Kafka later opnieuw kan bezoeken in een gespecificeerd interval om hetzelfde bericht opnieuw te lezen.
Houd er rekening mee dat de tijd waarin dit bericht opnieuw kan worden gelezen, beperkt is en kan worden geconfigureerd in Kafka-configuratie. Dus als die tijd voorbij is, kan een klant nooit meer een ouder bericht lezen.
Superkracht: RabbitMQ
De belangrijkste superkracht van RabbitMQ is dat het eenvoudig schaalbaar is, een krachtig wachtrijsysteem is met zeer goed gedefinieerde consistentieregels en de mogelijkheid om vele soorten berichtenuitwisselingsmodellen te creëren. Er zijn bijvoorbeeld drie soorten uitwisselingen die u kunt maken in RabbitMQ:
- Directe uitwisseling: één op één uitwisseling van onderwerp
- Onderwerp uitwisseling: A onderwerp is gedefinieerd waarop verschillende producenten een bericht kunnen publiceren en verschillende consumenten zich kunnen binden om over dat onderwerp te luisteren, zodat elk van hen het bericht ontvangt dat naar dit onderwerp wordt verzonden.
- Fanout-uitwisseling: Dit is strikter dan topic-uitwisseling, want wanneer een bericht wordt gepubliceerd op een fanout-uitwisseling, zullen alle consumenten die zijn verbonden met wachtrijen die zich binden aan de fanout-uitwisseling het bericht ontvangen.
Merk het verschil al tussen RabbitMQ en Kafka? Het verschil is dat als een consument niet is verbonden met een fanout-uitwisseling in RabbitMQ wanneer een bericht werd gepubliceerd, het verloren gaat omdat andere consumenten het bericht hebben geconsumeerd, maar dit gebeurt niet in Apache Kafka omdat elke consument elk bericht kan lezen net zo ze behouden hun eigen cursor.
RabbitMQ is gericht op makelaars
Een goede makelaar is iemand die garant staat voor het werk dat hij op zich neemt en dat is waar RabbitMQ goed in is. Het is gekanteld naar leveringsgaranties tussen producenten en consumenten, met voorbijgaande voorkeur boven duurzame boodschappen.
RabbitMQ gebruikt de makelaar zelf om de status van een bericht te beheren en ervoor te zorgen dat elk bericht wordt afgeleverd bij elke rechthebbende consument.
RabbitMQ gaat ervan uit dat consumenten voornamelijk online zijn.
Kafka is producentgericht
Apache Kafka is producentgericht omdat het volledig is gebaseerd op partitionering en een stroom van gebeurtenispakketten die gegevens bevatten en deze transformeren in duurzame berichtenmakelaars met cursors, ter ondersteuning van batchconsumenten die mogelijk offline zijn, of online consumenten die berichten willen met een lage latentie.
Kafka zorgt ervoor dat het bericht veilig blijft tot een bepaalde periode door het bericht op de knooppunten in het cluster te repliceren en een consistente status te behouden.
Dus, Kafka niet veronderstellen dat een van zijn consumenten voornamelijk online is en het kan hem niets schelen.
Bericht Bestellen
Met RabbitMQ, de bestelling van de publicatie wordt consistent beheerd en consumenten ontvangen het bericht in de gepubliceerde bestelling zelf. Aan de andere kant doet Kafka dit niet omdat het veronderstelt dat gepubliceerde berichten zwaar van aard zijn, dus consumenten zijn traag en kunnen berichten in elke volgorde verzenden, dus het beheert de bestelling ook niet zelf. We kunnen echter een vergelijkbare topologie opzetten om de bestelling in Kafka te beheren met behulp van de consistente hash-uitwisseling of sharding-plug-in., of zelfs meer soorten topologieën.
De volledige taak die door Apache Kafka wordt beheerd, is om te fungeren als een "schokdemper" tussen de continue stroom van gebeurtenissen en de consumenten waarvan sommige online zijn en andere offline kunnen - alleen batches die elk uur of zelfs dagelijks worden verbruikt.
Conclusie
In deze les hebben we de belangrijkste verschillen (en ook overeenkomsten) tussen Apache Kafka en RabbitMQ . bestudeerd. In sommige omgevingen hebben beide buitengewone prestaties laten zien, zoals RabbitMQ verbruikt miljoenen berichten per seconde en Kafka heeft meerdere miljoenen berichten per seconde verbruikt. Het belangrijkste architecturale verschil is dat RabbitMQ zijn berichten bijna in het geheugen beheert en dus een groot cluster (30+ nodes) gebruikt, terwijl Kafka feitelijk gebruik maakt van de kracht van sequentiële schijf-I/O-bewerkingen en minder hardware nodig heeft.
Nogmaals, het gebruik van elk van hen hangt nog steeds volledig af van de use-case in een applicatie. Veel plezier met berichten !
