De basis van Apache Kafka en streamverwerking · Les

Producer- en consumerperformance

Stem producer- en consumerconfiguraties af voor optimale doorvoer en latency in uw applicaties.

Les 1 van 411 stappen

Producer- en consumerperformance is een gratis De basis van Apache Kafka en streamverwerking-les op CoddyKit. Dit is les 1 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 De basis van Apache Kafka en streamverwerking. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus De basis van Apache Kafka en streamverwerking bevat in totaal 4 lessen.

Kafka-prestaties optimaliseren

Welkom bij het afstemmen van Kafka! We onderzoeken hoe je producers sneller gegevens kunt laten verzenden en consumers deze efficiënter kunt laten verwerken.

Prestaties gaan niet alleen over 'snelheid'. Het gaat vaak om een balans tussen doorvoer (hoeveel gegevens er per seconde worden verwerkt) en latentie (hoe snel één bericht wordt verwerkt).

De doorvoer van producers maximaliseren

Producers sturen berichten naar Kafka-onderwerpen. Voor een hoge doorvoer willen we dat ze gegevens in efficiënte blokken versturen, niet één voor één.

Belangrijke configuraties van producers bepalen hoeveel berichten worden gegroepeerd en hoe vaak ze worden verzonden.

Berichten bundelen voor efficiëntie

In plaats van elk bericht onmiddellijk te versturen, kunnen producers berichten verzamelen in batches. Dit vermindert de netwerkoverhead.

batch.size: De maximale grootte in bytes van één batch. Grotere batches betekenen minder verzoeken, wat de doorvoer verhoogt.
linger.ms: De maximale tijd die een producer wacht op meer berichten om een batch te vullen. Een waarde > 0 helpt bij het bundelen.

Gegevens van producers comprimeren

Kafka-producers kunnen berichtbatches comprimeren voordat ze deze versturen. Dit vermindert de hoeveelheid gegevens die over het netwerk wordt verzonden.

compression.type: Veelgebruikte opties zijn gzip, snappy, lz4 en zstd.

Compressie bespaart netwerkbandbreedte en schijfruimte op brokers, waardoor de doorvoer verder verbetert. Compressie en decomprimeren kosten wel een kleine hoeveelheid CPU-capaciteit.

Betrouwbaarheid versus latentie met acks

De instelling acks bepaalt hoeveel bevestigingen van brokers een producer nodig heeft voordat deze een bericht als verzonden beschouwt.

acks=0: De producer wacht op geen enkele bevestiging. Het snelst, maar met de laagste betrouwbaarheid (gegevensverlies is mogelijk).
acks=1: De producer wacht tot de leader-broker bevestigt. Een goede balans tussen snelheid en betrouwbaarheid.
acks=all (of -1): De producer wacht tot alle replica's die synchroon lopen bevestigen. Het langzaamst, maar met de hoogste betrouwbaarheid (geen gegevensverlies als de leader uitvalt).

Voorbeeld van een afgestemde producer

Hier volgt een eenvoudige Kafka-producer die is geconfigureerd met enkele van de afstemmingsparameters die we hebben besproken. Probeer de waarden te wijzigen en de producer uit te voeren!

import org.apache.kafka.clients.producer.*;
import java.util.Properties;

public class TunedProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // Tuning parameters
        props.put("batch.size", 16384 * 4); // Increase batch size (default 16KB)
        props.put("linger.ms", 50);        // Wait up to 50ms for more messages
        props.put("compression.type", "snappy"); // Enable compression
        props.put("acks", "1");            // Acks setting

        Producer<String, String> producer = new KafkaProducer<>(props);
        try {
            for (int i = 0; i < 100; i++) {
                ProducerRecord<String, String> record =
                    new ProducerRecord<>("my_topic", Integer.toString(i), "message_" + i);
                producer.send(record);
            }
            System.out.println("100 messages sent to my_topic.");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            producer.close();
        }
    }
}

De doorvoer van consumers optimaliseren

Consumers lezen berichten uit Kafka-topics. Efficiënt consumeren betekent dat je berichten snel verwerkt en tegelijkertijd het tempo van de producer bijhoudt.

Net als producers kunnen consumers berichten in batches ophalen, waardoor het aantal verzoeken aan de brokers afneemt.

Berichten efficiënt ophalen

Verschillende consumerinstellingen bepalen hoeveel berichten tegelijk worden opgehaald en hoe het pollen werkt:

max.poll.records: Het maximale aantal records dat in één aanroep van poll() wordt teruggegeven. Een hogere waarde betekent dat er per poll meer records worden verwerkt, wat de verwerkingscapaciteit verhoogt.
fetch.min.bytes: De minimale hoeveelheid gegevens in bytes waarop de consumer wacht voordat deze gegevens bij de broker ophaalt. Wachten op meer gegevens kan de verwerkingscapaciteit verhogen doordat het aantal verzoeken afneemt.
fetch.max.wait.ms: De maximale tijd die de broker wacht totdat fetch.min.bytes beschikbaar is voordat deze gegevens verstuurt.

Automatisch committen versus handmatig committen

Kafka-consumers houden hun voortgang bij met offsets. Een offset committen betekent dat je berichten tot en met dat punt als verwerkt markeert.

enable.auto.commit: Als dit true is (standaard), worden offsets automatisch op de achtergrond gecommit. Dat is handig, maar kan bij een crash leiden tot dubbele verwerking of gegevensverlies.
auto.commit.interval.ms: Hoe vaak automatische commits plaatsvinden. Als je dit interval verkleint, kan het risico op duplicaten afnemen, maar neemt de overhead toe.

Voor hoge prestaties en betrouwbaarheid kiezen veel applicaties ervoor offsets handmatig te committen.

Afstemmen op verwerkingscapaciteit

Stel je een scenario voor waarin je de verwerkingscapaciteit van een Kafka-producer moet maximaliseren.

Beantwoord dit in de interactieve les

Samenvatting: producers en consumers afstemmen

We hebben de belangrijkste configuraties behandeld voor het optimaliseren van de prestaties van Kafka-producers en -consumers:

Producers: Stem batch.size, linger.ms en compression.type af voor een hogere verwerkingscapaciteit. Zoek bij acks een balans tussen betrouwbaarheid en latentie.
Consumers: Pas max.poll.records, fetch.min.bytes en fetch.max.wait.ms aan om berichten efficiënt op te halen. Begrijp de afwegingen tussen automatisch en handmatig committen.

Onthoud dat afstemmen draait om het vinden van de juiste balans voor de behoeften van jouw specifieke applicatie.

Gratis beginnen

Leer De basis van Apache Kafka en streamverwerking 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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Producer- en consumerperformance” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad De basis van Apache Kafka en streamverwerking, waaronder “Producer- en consumerperformance”, 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 De basis van Apache Kafka en streamverwerking bevat in totaal 4 lessen.

Wat leer ik in “Producer- en consumerperformance”?

Stem producer- en consumerconfiguraties af voor optimale doorvoer en latency in uw applicaties. Je oefent met De basis van Apache Kafka en streamverwerking 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 De basis van Apache Kafka en streamverwerking te beginnen?

Ervaring vooraf is niet nodig. De basis van Apache Kafka en streamverwerking 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 1 van 4.

Hoe lang duurt de les “Producer- en consumerperformance”?

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 De basis van Apache Kafka en streamverwerking?

Ja. Elke les over De basis van Apache Kafka en streamverwerking 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

← Terug naar De basis van Apache Kafka en streamverwerking