Phenquestions
Apache Kafka
Laten we voor een definitie op hoog niveau een korte definitie voor Apache Kafka geven:
Apache Kafka is een gedistribueerd, fouttolerant, horizontaal schaalbaar, commit-logboek.
Dat waren enkele hoogstaande woorden over Apache Kafka. Laten we de concepten hier in detail begrijpen.
- Verdeeld: Kafka verdeelt de gegevens die het bevat in meerdere servers en elk van deze servers kan verzoeken van clients verwerken voor het delen van gegevens dat het bevat
- Fouttolerant: Kafka heeft geen Single Point of Failure. In een SPoF-systeem, zoals een MySQL-database, als de server waarop de database wordt gehost uitvalt, wordt de toepassing genaaid. In een systeem dat geen SPoF heeft en uit meerdere knooppunten bestaat, zelfs als het grootste deel van het systeem uitvalt, is het nog steeds hetzelfde voor een eindgebruiker.
- Horizontaal schaalbaar: Dit soort schaalvergroting verwijst naar het toevoegen van meer machines aan een bestaande cluster. Dit betekent dat Apache Kafka in staat is meer nodes in zijn cluster te accepteren en geen uitvaltijd biedt voor vereiste upgrades van het systeem. Bekijk de onderstaande afbeelding om het type scailing-concepten te begrijpen:
- Logboek vastleggen: Een vastleggingslogboek is een gegevensstructuur, net als een gekoppelde lijst. Het voegt alle berichten toe die erop komen en handhaaft altijd hun volgorde. Gegevens kunnen niet uit dit logboek worden verwijderd totdat een bepaalde tijd voor die gegevens is bereikt.
Verticale en horizontale schaalvergroting
Een onderwerp in Apache Kafka is net een wachtrij waarin berichten worden opgeslagen. Deze berichten worden gedurende een instelbare tijd opgeslagen en het bericht wordt pas verwijderd als deze tijd is verstreken, zelfs als het door alle bekende consumenten is gebruikt.
Kafka is schaalbaar omdat het de consumenten zijn die het bericht dat het laatst door hen is opgehaald, daadwerkelijk opslaan als een 'offset'-waarde. Laten we eens kijken naar een figuur om dit beter te begrijpen:
Onderwerpverdeling en consumentencompensatie in Apache Kafka
Aan de slag met Apache Kafka
Om Apache Kafka te gaan gebruiken, moet het op de machine zijn geïnstalleerd. Lees hiervoor Apache Kafka installeren op Ubuntu.
Zorg ervoor dat je een actieve Kafka-installatie hebt als je voorbeelden wilt proberen die we later in de les zullen presenteren.
Hoe werkt het?
Met Kafka, de Producent toepassingen publiceren berichten die aankomt bij een Kafka Knooppunt en niet rechtstreeks aan een Consument. Vanuit deze Kafka Node worden berichten geconsumeerd door de Klant toepassingen.
Kafka Producent en Consument
Omdat een enkel onderwerp veel gegevens in één keer kan krijgen, is om Kafka horizontaal schaalbaar te houden, elk onderwerp onderverdeeld in partities en elke partitie kan leven op elke node-machine van een cluster. Laten we proberen het voor te stellen:
Onderwerppartities
Nogmaals, Kafka Broker houdt niet bij welke consument hoeveel datapakketten heeft verbruikt. Het is de de verantwoordelijkheid van de consument om bij te houden welke gegevens zijn verbruikt.
Persistentie op schijf
Kafka bewaart de berichtrecords die het van Producers krijgt op schijf en bewaart ze niet in het geheugen. Een vraag die kan rijzen is hoe dit dingen haalbaar en snel maakt? Dit heeft verschillende redenen waardoor het een optimale manier is om de berichtenrecords te beheren:
- Kafka volgt een protocol voor het groeperen van de berichtrecords. Producenten produceren berichten die in grote brokken op schijf worden bewaard en consumenten consumeren deze berichtrecords ook in grote lineaire brokken.
- De reden dat het schrijven van de schijf lineair is, is dat dit het lezen snel maakt vanwege de sterk verminderde lineaire leestijd van de schijf.
- Lineaire schijfbewerkingen worden geoptimaliseerd door: Besturingssystemen ook door gebruik te maken van technieken van achter schrijven en Lees vooruit.
- Moderne besturingssystemen gebruiken ook het concept van: Paginacaching wat betekent dat ze sommige schijfgegevens in het vrije beschikbare RAM-geheugen opslaan.
- Omdat Kafka gegevens in een uniforme standaardgegevens in de hele stroom van producent tot consument vasthoudt, maakt het gebruik van de zero-copy optimalisatie werkwijze.
Gegevensdistributie en -replicatie
Zoals we hierboven hebben bestudeerd dat een onderwerp is verdeeld in partities, wordt elk berichtrecord gerepliceerd op meerdere knooppunten van het cluster om de volgorde en gegevens van elk record te behouden in het geval dat een van de knooppunten sterft.
Ook al wordt een partitie op meerdere knooppunten gerepliceerd, er is nog steeds een partitie leider knooppunt waardoor applicaties gegevens over het onderwerp lezen en schrijven en de leider gegevens repliceert op andere knooppunten, die worden genoemd als volgers van die partitie.
Als de berichtrecordgegevens van groot belang zijn voor een toepassing, kan de garantie dat het berichtrecord veilig is in een van de knooppunten worden vergroot door de replicatiefactor van de Cluster.
Wat is Dierenverzorger??
Zookeeper is een zeer fouttolerante, gedistribueerde sleutelwaardeopslag. Apache Kafka is sterk afhankelijk van Zookeeper voor het opslaan van clustermechanica zoals de hartslag, het distribueren van updates/configuraties, enz.).
Het stelt de Kafka-makelaars in staat zich op zichzelf te abonneren en te weten wanneer er een wijziging is opgetreden met betrekking tot een partitieleider en knooppuntdistributie.
Producenten- en consumententoepassingen communiceren rechtstreeks met Zookeeper applicatie om te weten welk knooppunt de partitieleider is voor een onderwerp, zodat ze lees- en schrijfbewerkingen kunnen uitvoeren vanuit de partitieleider.
Streamen
Een streamprocessor is een hoofdcomponent in een Kafka-cluster die een continue stroom berichtrecordgegevens van invoeronderwerpen haalt, deze gegevens verwerkt en een gegevensstroom creëert om onderwerpen uit te voeren die van alles kunnen zijn, van prullenbak tot een database.
Het is heel goed mogelijk om eenvoudige verwerking rechtstreeks uit te voeren met behulp van de producent/consumenten-API's, maar voor complexe verwerking zoals het combineren van streams, biedt Kafka een geïntegreerde Streams API-bibliotheek, maar houd er rekening mee dat deze API bedoeld is om te worden gebruikt binnen onze eigen codebase en dat doet het niet' t lopen op een makelaar. Het werkt vergelijkbaar met de consumenten-API en helpt ons het streamverwerkingswerk over meerdere applicaties uit te schalen.
Wanneer Apache Kafka . gebruiken?
Zoals we in de bovenstaande secties hebben bestudeerd, kan Apache Kafka worden gebruikt om een groot aantal berichtrecords af te handelen die tot een vrijwel oneindig aantal onderwerpen in onze systemen kunnen behoren.
Apache Kafka is een ideale kandidaat als het gaat om het gebruik van een service waarmee we gebeurtenisgestuurde architectuur in onze applicaties kunnen volgen. Dit komt door de mogelijkheden van datapersistentie, fouttolerante en sterk gedistribueerde architectuur waar kritieke applicaties kunnen vertrouwen op zijn prestaties.
De schaalbare en gedistribueerde architectuur van Kafka maakt integratie met microservices zeer eenvoudig en stelt een applicatie in staat zichzelf te ontkoppelen met veel bedrijfslogica.
Een nieuw onderwerp maken
We kunnen een testonderwerp maken testen op Apache Kafka-server met het volgende commando:
Een onderwerp maken
sudo kafka-onderwerpen.sh --create --zookeeper localhost:2181 --replicatiefactor 1--partities 1 --onderwerp testen
Dit is wat we terugkrijgen met deze opdracht:
Nieuw Kafka-onderwerp maken
Er wordt een testonderwerp gemaakt dat we kunnen bevestigen met het genoemde commando:
Kafka Onderwerp aanmaak bevestiging
Berichten schrijven over een onderwerp
Zoals we eerder hebben bestudeerd, is een van de API's die aanwezig zijn in Apache Kafka de Producer-API. We zullen deze API gebruiken om een nieuw bericht te maken en te publiceren naar het onderwerp dat we zojuist hebben gemaakt:
Bericht naar onderwerp schrijven
sudo kafka-console-producer.sh --broker-list localhost:9092 --topic testingLaten we de uitvoer voor deze opdracht bekijken:
Bericht publiceren naar Kafka Topic
Zodra we op de toets drukken, zien we een nieuw pijlteken (>), wat betekent dat we nu gegevens kunnen bekijken:
Een bericht typen
Typ gewoon iets in en druk op om een nieuwe regel te beginnen. Ik typte 3 regels tekst in:
Berichten lezen van onderwerp
Nu we een bericht hebben gepubliceerd over het Kafka-onderwerp dat we hebben gemaakt, zal dit bericht daar gedurende een instelbare tijd staan. We kunnen het nu lezen met de Consumenten-API:
Berichten lezen van onderwerp
sudo kafka-console-consumer.sh --dierenverzorger localhost:2181 --onderwerp testen --vanaf het begin
Dit is wat we terugkrijgen met deze opdracht:
Commando om Bericht van Kafka Topic te lezen
We kunnen de berichten of regels zien die we hebben geschreven met behulp van de Producer API, zoals hieronder weergegeven:
Als we nog een nieuw bericht schrijven met behulp van de Producer API, wordt dit ook direct weergegeven aan de kant van de consument:
Publiceren en consumeren tegelijk
Conclusie
In deze les hebben we gekeken hoe we Apache Kafka gaan gebruiken, wat een uitstekende Message Broker is en ook kan fungeren als een speciale gegevenspersistentie-eenheid.
