Introduktion till Kafka Consumer Group
Kafka konsumentgrupp är i princip ett antal Kafka-konsumenter som kan läsa data parallellt från ett Kafka-ämne. En Kafka Consumer Group har följande egenskaper:
- Alla konsumenter i en grupp har samma grupp.id.
- Varje partition i ämnet läses av endast en konsument.
- Det maximala antalet konsumenter är lika med antalet partitioner i ämnet. Om det finns fler konsumenter än partitioner, kommer vissa av konsumenterna att förbli inaktiva.
- En konsument kan läsa från mer än en partition.
Betydelsen av Kafka Consumer Group
För en detaljhandelsorganisation kommer det att finnas ett stort antal producenter som genererar data till en enorm takt. För att kunna läsa en stor mängd data behöver vi flera konsumenter som körs parallellt. Det är jämförelsevis lättare på Producer-sidan där varje producent genererar data oberoende av de andra. Men på konsumentens sida, om vi har mer än en konsument som läser från samma ämne, finns det en stor chans att varje meddelande kommer att läsas mer än en gång. Kafka löser problemet med Consumer Group. I alla fall får endast en konsument läsa data från en partition.
Partitioner av Kafka Consumer Group
Låt oss anta att vi har ett Kafka-ämne och det finns fyra partitioner i det. Då kan vi ha följande scenarier:
1. Antal konsumenter = Antal partitioner
I detta fall kommer varje konsument att läsa data från varje partition och detta är det ideala fallet.
2. Antal konsumenter> Antal partitioner
I det här fallet kommer en konsument att förbli inaktiv och leder till dåligt utnyttjande av resursen.
3. Antal konsumenter <Antal partitioner
I detta fall kommer en av konsumenterna att läsa data från mer än en partition.
4. Antal konsumentgrupper> 1
I detta fall prenumereras ämnet av mer än en konsumentgrupp som tillgodoser två olika applikationer. De två applikationerna kan köras oberoende av varandra.
Fördelar med Kafka Consumer Group
Konsumentgruppen lägger till följande fördelar:
- Skalbarhet: Ett antal konsumenter som läser data parallellt ökar definitivt datakonsumtionshastigheten och gör att systemet kan läsa en stor datamängd.
- Feltolerans: Anta att vi bara hade en konsument (för att inte läsa så stor datamängd), vad skulle hända om konsumenten misslyckas av någon anledning? Hela pipeline kommer att gå sönder.
- Belastningsbalansering: Kafka delar partitionerna rättvis till varje konsument, vilket gör dataförbrukningsprocessen smidig och effektiv.
- Ombalansering: Om en ny konsument läggs till eller en befintlig slutar, balanserar Kafka belastningen på tillgängliga konsumenter.
Hur Kafka överbryggar de två modellerna?
Låt oss diskutera de två meddelandemodellerna först.
1. Meddelandeköer
I denna modell skickas en ström av meddelanden från en producent till endast en konsument. Således läses varje meddelande endast en gång och när en konsument drar ett meddelande raderas meddelandet från kön. Ett typiskt exempel kan vara att utfärda en lönecheck där varje lönecheck endast måste utfärdas en gång. Den här modellen säkerställer inte att meddelanden kommer att levereras i ordning. Skalbarheten för bearbetning av meddelanden är begränsad till en enda domän.
2. Publicera-prenumerera meddelanden
I den här modellen kan meddelandena som publiceras av en producent prenumereras av mer än en konsument. Tillverkaren och konsumenten kopplas från i stor utsträckning. Denna modell säkerställer att varje konsument kommer att få meddelanden i ett ämne i exakt ordning genererad av producenten. Ett typiskt exempel kan vara en disk-TV som publicerar olika kanaler som musik, film, sport etc., och konsumenterna kan prenumerera på mer än en kanal. Eftersom det finns flera prenumeranter på ett ämne är det en utmaning att skala bearbetningen av strömmar.
Kafka är så populär eftersom även om den är baserad på publicera-prenumerationsmodellen har den fördelarna med ett meddelandekössystem. Som diskuterats tidigare, om vi har en konsumentgrupp, säkerställer Kafka att varje meddelande i ett ämne läses endast en gång av en konsument (vilket liknar ett meddelande kösystem). De extra fördelarna är att meddelandena behålls av mäklarna (under en tid och därmed gör det feltolerant) och om vi har mer än en konsumentgrupp kan de läsa meddelanden från samma ämne men behandla dem annorlunda.
Använd fallimplicering
Låt oss anta att vi har en enkel molnplattform där vi tillåter följande operationer för användare:
- Lagra filer på Cloud.
- Visa deras filer i molnet.
- Ladda ner deras filer från molnet.
I början hade vi en mycket liten användarbas. Vi ville härleda olika statistik (på timbasis) som aktiva användare, antal uppladdningsbegäranden, antal nedladdningsbegäranden och så vidare. För att uppfylla kraven skapar vi ett Kafka Cluster som producerar loggarna (genererade av vår applikation) till ett ämne och det finns ett program som konsumerar ämnet (med en konsument) och sedan bearbetar det för att generera den nödvändiga statistiken och slutligen visa de på en webbsida.
När människor började tycka om våra tjänster började fler använda dem och genererade därför många timmar per timme. Vi fann att applikationen som förbrukar ämnet blev extremt långsam eftersom vi bara använde en konsument. För att lösa problemet lade vi till några konsumenter till gruppen och fann betydande förbättringar i prestanda.
Vi stötte på ett annat krav, där vi var tvungna att skriva loggarna i ett HDFS-kluster och denna process skulle köras oberoende av den tidigare applikationen (Det beror på att med ytterligare dataökning planerade vi att avveckla den första applikationen och hämta all statistik i HDFS-miljön). För att uppfylla detta krav utvecklade vi en annan applikation som prenumererade på ämnet med en annan konsumentgrupp och skrev data in i HDFS-klustret.
Rekommenderade artiklar
Detta är en guide till Kafka Consumer Group. Här diskuterar vi vikten av Kafka konsumentgrupp och hur Kafka överbryggar två modeller tillsammans med dess användningsfall implikation. Du kan också titta på följande artiklar för att lära dig mer-
- Kafka-applikationer
- Hur installerar jag Kafka?
- Kafka intervjufrågor
- HDFS Arkitektur
- Olika typer av Kafka-verktyg