Consumergroepen beheren
Krijg inzicht in hoe consumergroepen parallelle verwerking en fouttolerantie mogelijk maken, zodat berichten per groep slechts eenmaal worden verwerkt.
Consumergroepen beheren is een gratis Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka)-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) bevat in totaal 4 lessen.
Wat zijn consumentengroepen?
Welkom! Vandaag bekijken we consumentengroepen in Kafka. Dit is een kernconcept voor het schalen van berichtconsumptie en het waarborgen van fouttolerantie.
Zie een consumentengroep als een team van consumenten dat samen berichten uit een of meer topics verwerkt. Elk bericht uit de partities van een topic wordt slechts aan één consument binnen die specifieke groep geleverd.
Schalen en fouttolerantie
Consumentengroepen lossen twee belangrijke uitdagingen op:
- Schalen: door partities over meerdere consumenten te verdelen, kun je berichten veel sneller verwerken en de doorvoer van je toepassing verhogen.
- Fouttolerantie: als een consument uitvalt of de groep verlaat, wijst Kafka de partities automatisch opnieuw toe aan andere actieve consumenten in dezelfde groep. Zo blijft de berichtverwerking doorgaan.
Uiteindelijk wordt een bericht precies één keer per consumentengroep verwerkt, zelfs als er meerdere consumenten zijn.
Partities en consumenten
Om groepen te begrijpen, moet je onthouden dat Kafka-topics zijn verdeeld in partities. Deze partities vormen de eenheid voor parallelle verwerking.
- Binnen een consumentengroep wordt elke partitie aan hoogstens één consument toegewezen.
- Als je in een groep meer consumenten dan partities hebt, zijn sommige consumenten inactief.
- Als je minder consumenten dan partities hebt, verwerken sommige consumenten meerdere partities.
Deze toewijzingsstrategie zorgt voor verwerking in de juiste volgorde binnen elke partitie, terwijl parallelle verwerking over meerdere partities mogelijk blijft.
Dynamische herbalancering van partities
Kafka is slim! Wanneer een consument lid wordt van een groep of deze verlaat (bijvoorbeeld wanneer een toepassing wordt gestart, gestopt of onverwacht beëindigt), start Kafka automatisch een herbalancering.
Tijdens een herbalancering worden partities dynamisch opnieuw toegewezen aan de actieve consumenten in de groep. Zo blijven alle partities geconsumeerd worden en kan Kafka zich aanpassen aan veranderingen in de schaalbehoeften van je toepassing.
Herbalancering is een automatisch proces dat hoge beschikbaarheid garandeert en zich aanpast aan wisselende werklasten.
`group.id` in Spring Kafka
In Spring Kafka bepaal je tot welke consumentengroep je listener behoort met de eigenschap group.id.
Deze unieke tekenreeks identificeert je consumentengroep bij Kafka. Alle consumenten (binnen dezelfde instantie van de toepassing of in verschillende instanties) die exact dezelfde group.id delen, worden beschouwd als onderdeel van dezelfde groep.
Je configureert dit meestal in application.properties of rechtstreeks in de annotatie @KafkaListener.
Voorbeeld van een Spring-listener
Hier zie je een eenvoudige Spring Boot Kafka-listener die is geconfigureerd met een specifieke group.id. Hiermee geef je Kafka aan dat deze listener deel uitmaakt van de consumentengroep 'my-first-group'.
Voer dit voorbeeld uit en bekijk de uitvoer!
package com.coddykit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
@SpringBootApplication
public class ConsumerGroupApp {
public static void main(String[] args) {
SpringApplication.run(ConsumerGroupApp.class, args);
}
@Component
public static class MyKafkaListener {
@KafkaListener(topics = "my-topic", groupId = "my-first-group")
public void listen(String message) {
System.out.println("Received in Group 1: " + message);
}
}
}Schalen met meerdere consumenten
Om parallelle verwerking en een hogere doorvoer voor een topic te bereiken, kun je meerdere instanties van je toepassing uitvoeren die allemaal dezelfde zelfde group.id hebben.
Kafka verdeelt de partities van het topic vervolgens over deze actieve instanties. Elke instantie verwerkt onafhankelijk een deelverzameling van de partities, waardoor je de berichtconsumptie effectief opschaalt.
Dit is de belangrijkste manier om topics met grote volumes efficiënt te verwerken.
Meerdere listeners, dezelfde groep
Je kunt ook meerdere @KafkaListener-methoden definiëren binnen dezelfde instantie van een Spring Boot-toepassing, die allemaal tot dezelfde consumentengroep behoren.
Spring Kafka beheert deze als afzonderlijke consumenten binnen die groep. Als het topic voldoende partities heeft, kunnen deze listeners berichten uit verschillende partities parallel verwerken binnen één toepassing.
Het attribuut id helpt listener-beans van elkaar te onderscheiden, vooral wanneer meerdere listeners voor hetzelfde topic en dezelfde groep zijn gedefinieerd.
package com.coddykit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
@SpringBootApplication
public class MultiListenerApp {
public static void main(String[] args) {
SpringApplication.run(MultiListenerApp.class, args);
}
@Component
public static class MyMultiKafkaListeners {
// Consumer 1 for "my-topic" in "my-app-group"
@KafkaListener(topics = "my-topic", groupId = "my-app-group", id = "listener1")
public void listen1(String message) {
System.out.println("Listener 1 received: " + message);
}
// Consumer 2 for "my-topic" in "my-app-group"
@KafkaListener(topics = "my-topic", groupId = "my-app-group", id = "listener2")
public void listen2(String message) {
System.out.println("Listener 2 received: " + message);
}
}
}Onafhankelijke consumptie
Wat als verschillende toepassingen dezelfde berichten uit een topic moeten verwerken, maar voor verschillende doeleinden?
Daar komen meerdere consumentengroepen goed van pas. Je kunt meerdere afzonderlijke consumentengroepen hebben, elk met een unieke group.id, die hetzelfde Kafka-topic consumeren.
Elke groep ontvangt een volledige kopie van alle berichten die naar dat topic zijn gepubliceerd. Zo kunnen groepen onafhankelijk verwerken zonder andere groepen te beïnvloeden.
Controle van groepsbeheer
Stel dat een Kafka-topic 3 partities heeft. Je start een toepassing met één consumentengroep en twee actieve consumenten. Hoe worden de berichten verdeeld?
Samenvatting van consumentengroepen
Je hebt geleerd hoe krachtig Kafka-consumentengroepen zijn!
- Ze zijn essentieel voor het schalen van berichtconsumptie en het bouwen van fouttolerante toepassingen.
- Berichten uit de partities van een topic worden verdeeld over consumenten in een groep en precies één keer per groep verwerkt.
- Kafka handelt partitietoewijzing en herbalancering automatisch af wanneer consumenten zich bij een groep aansluiten of deze verlaten.
- Met verschillende waarden voor
group.idkunnen meerdere toepassingen dezelfde berichtenstroom onafhankelijk consumeren.
Het beheersen van consumentengroepen is essentieel voor het bouwen van robuuste Kafka-toepassingen.
Leer Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Consumergroepen beheren” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka), waaronder “Consumergroepen beheren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) bevat in totaal 4 lessen.
Wat leer ik in “Consumergroepen beheren”?
Krijg inzicht in hoe consumergroepen parallelle verwerking en fouttolerantie mogelijk maken, zodat berichten per groep slechts eenmaal worden verwerkt. Je oefent met Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) te beginnen?
Ervaring vooraf is niet nodig. Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Consumergroepen beheren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka)?
Ja. Elke les over Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Kafka-listenercontainers bouwen
- Consumergroepen beheren
- Deserialisatie en berichtconversie
- Batchverbruik en acknowledgmentmodi