Apache Kafka er en åpen kildekode, distribuert, skalerbar, høy ytelse, melding megler for publiser abonnement. Det er et godt valg for å bygge systemer som er i stand til å behandle store datamengder. I denne artikkelen ser vi på hvordan vi kan lage en produsent- og forbrukerapplikasjon for Kafka i C #.
For å komme i gang med å bruke Kafka, bør du laste ned Kafka og ZooKeeper og installere dem på systemet ditt. Denne DZone-artikkelen inneholder trinnvise instruksjoner for å sette opp Kafka og ZooKeeper på Windows. Når du er ferdig med oppsettet, starter du ZooKeeper og Kafka og møter meg her.
Apache Kafka-arkitektur
I denne delen vil vi undersøke de arkitektoniske komponentene og tilhørende terminologi i Kafka. I utgangspunktet består Kafka av følgende komponenter:
- Kafka Cluster — en samling av en eller flere servere kjent som meglere
- Produsent - komponenten som brukes til å publisere meldinger
- Forbruker - komponenten som brukes til å hente eller konsumere meldinger
- ZooKeeper - en sentralisert koordineringstjeneste som brukes til å opprettholde konfigurasjonsinformasjon på tvers av klyngenoder i et distribuert miljø
Den grunnleggende dataenheten i Kafka er en melding. En melding i Kafka er representert som et nøkkelverdipar. Kafka konverterer alle meldinger til byte-arrays. Det skal bemerkes at kommunikasjon mellom produsenter, forbrukere og klynger i Kafka bruker TCP-protokollen. Hver server i en Kafka-klynge er kjent som megler. Du kan skalere Kafka horisontalt ved å legge til flere meglere i klyngen.
Diagrammet nedenfor illustrerer de arkitektoniske komponentene i Kafka - et høyt nivå.
Apache-STIFTELSEEt emne i Kafka representerer en logisk samling av meldinger. Du kan tenke på det som en feed eller kategori som en produsent kan publisere meldinger til. Forresten inneholder en Kafka-megler ett eller flere emner som igjen er delt inn i en eller flere partisjoner. En partisjon er definert som en ordnet sekvens av meldinger. Partisjoner er nøkkelen til Kafkas evne til å skalere dynamisk, ettersom partisjoner er fordelt på flere meglere.
Du kan ha en eller flere produsenter som skyver meldinger inn i en klynge til enhver tid. En produsent i Kafka publiserer meldinger i et bestemt emne, og en forbruker abonnerer på et emne for å motta meldingene.
Velge mellom Kafka og RabbitMQ
Både Kafka og RabbitMQ er populære open source-meldingsmeglere som har vært i bred bruk i ganske lang tid. Når skal du velge Kafka fremfor RabbitMQ? Valget avhenger av noen få faktorer.
RabbitMQ er en hurtigmeldingsmegler skrevet i Erlang. De rike rutemulighetene og evnen til å tilby bekreftelser per melding er sterke grunner til å bruke den. RabbitMQ tilbyr også et brukervennlig nettgrensesnitt som du kan bruke til å overvåke RabbitMQ-serveren din. Ta en titt på artikkelen min for å lære å jobbe med RabbitMQ i .Net.
Når det gjelder å støtte store distribusjoner, skalerer Kafka imidlertid mye bedre enn RabbitMQ - alt du trenger å gjøre er å legge til flere partisjoner. Det skal også bemerkes at RabbitMQ-klynger ikke tåler nettverkspartisjoner. Hvis du planlegger å gruppere RabbitMQ-servere, bør du i stedet bruke føderasjoner. Du kan lese mer om RabbitMQ-klynger og nettverkspartisjoner her.
Kafka overstreker også klart RabbitMQ i ytelse. En enkelt Kafka-forekomst kan håndtere 100 000 meldinger per sekund, mot nærmere 20 000 meldinger per sekund for RabbitMQ. Kafka er også et godt valg når du vil overføre meldinger med lav ventetid for å støtte batchforbrukere, forutsatt at forbrukerne kan være enten online eller offline.
Bygger Kafka-produsenten og Kafka-forbrukeren
I denne delen vil vi undersøke hvordan vi kan bygge en produsent og forbruker for bruk med Kafka. For å gjøre dette vil vi bygge to konsollapplikasjoner i Visual Studio - en av dem vil representere produsenten og den andre forbrukeren. Og vi må installere en Kafka-leverandør for .Net i både produsenten og forbrukerapplikasjonen.
Forresten er det mange leverandører tilgjengelig, men i dette innlegget bruker vi kafka-net, en innfødt C # -klient for Apache Kafka. Du kan installere kafka-net via NuGet pakkebehandling fra Visual Studio. Du kan følge denne lenken til kafka-net GitHub-depotet.
Her er hovedmetoden for vår Kafka-produsent:
statisk tomrom Main (streng [] args){
streng nyttelast;
strengemne;
Melding msg = ny melding (nyttelast);
Uri uri = ny Uri (“// localhost: 9092”);
var alternativer = nye KafkaOptions (uri);
var router = ny BrokerRouter (opsjoner);
var klient = ny produsent (router);
client.SendMessageAsync (emne, ny liste {msg}). Vent ();
Console.ReadLine ();
}
Og her er koden for vår Kafka-forbruker:
statisk tomrom Main (streng [] args){
strengemne;
Uri uri = ny Uri (“// localhost: 9092”);
var alternativer = nye KafkaOptions (uri);
var router = ny BrokerRouter (opsjoner);
var forbruker = ny forbruker (nye forbrukeralternativer (emne, ruter));
foreach (var melding i forbruker.Consume ())
{
Console.WriteLine (Encoding.UTF8.GetString (message.Value));
}
Console.ReadLine ();
}
Merk at du bør inkludere Kafka-navnene i både produsent- og forbrukerapplikasjoner som vist nedenfor.
ved hjelp av KafkaNet;ved hjelp av KafkaNet.Model;
ved hjelp av KafkaNet.Protocol;
Til slutt er det bare å kjøre produsenten (produsenten først) og deretter forbrukeren. Og det er det! Du bør se meldingen "Velkommen til Kafka!" vises i vinduet til forbrukerkonsollen.
Mens vi har mange meldingssystemer å velge mellom - RabbitMQ, MSMQ, IBM MQ Series osv. - ligger Kafka foran pakken når det gjelder å håndtere store datastrømmer som kan stamme fra mange utgivere. Kafka brukes ofte til IoT-applikasjoner og loggaggregering og andre brukstilfeller som krever lav ventetid og sterke meldingsleveringsgarantier.
Hvis applikasjonen din trenger en rask og skalerbar meldingsmegler, er Kafka et godt valg. Følg med for flere innlegg på Kafka i denne bloggen.
