Grunnleggende Apache Kafka og strømming · leksjon

Utforming for høy gjennomstrømming

Lær arkitektoniske hensyn og anbefalte fremgangsmåter for å bygge Kafka-baserte systemer som håndterer enorme datamengder.

Leksjon 1 av 413 trinn

Utforming for høy gjennomstrømming er en gratis leksjon i Grunnleggende Apache Kafka og strømming på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Grunnleggende Apache Kafka og strømming, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Grunnleggende Apache Kafka og strømming inneholder totalt 4 leksjoner.

Hva er høy gjennomstrømming?

I Kafka betyr høy gjennomstrømming at systemet effektivt kan behandle enorme datamengder per sekund eller minutt. Dette er avgjørende for applikasjoner som sanntidsanalyse, innsamling av IoT-data og loggaggregering, der data kommer kontinuerlig og i høyt tempo.

Ved å utforme systemet for høy gjennomstrømming sikrer du at Kafka-klyngen og applikasjonene kan håndtere toppbelastninger uten redusert ytelse, datatap eller betydelige forsinkelser.

Viktige faktorer for gjennomstrømming

Høy gjennomstrømming i Kafka oppnås ved å optimalisere flere innbyrdes avhengige komponenter. Se på det som en kjede – det svakeste leddet begrenser den totale hastigheten.

Produsenter: Hvor effektivt de sender data.
Meglere: Hvor raskt de lagrer og leverer data.
Konsumenter: Hvor raskt de leser og behandler data.
Infrastruktur: Nettverksbåndbredde og hastighet for disk-I/O.

Optimalisering av produsenter: bunting

Det er ineffektivt å sende meldinger én etter én. Produsenter kan bunte meldinger og sende flere poster i én enkelt forespørsel. Dette reduserer nettverksoverhead og forbedrer gjennomstrømmingen.

batch.size: Maksimal størrelse i byte for én bunt.
linger.ms: Maksimal tid en produsent venter før den sender en bunt, selv om den ikke er full.

Ved å justere disse balanserer du ventetid (hvor raskt en melding sendes) mot gjennomstrømming (hvor mange meldinger som sendes over tid).

Eksempel på produsent med bunting

Slik konfigurerer du en produsent for bunting. Legg merke til innstillingene batch.size og linger.ms.

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;

public class HighThroughputProducer {

    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");

        // High throughput settings
        props.put("batch.size", 65536); // 64 KB batch size
        props.put("linger.ms", 10);    // Wait up to 10 ms for more records
        props.put("compression.type", "snappy"); // Compress batches
        props.put("acks", "1");         // Acks=1 for good balance

        try (KafkaProducer<String, String> producer = new KafkaProducer<>(props)) {
            for (int i = 0; i < 1000; i++) {
                String message = "Hello Kafka Throughput - " + i;
                producer.send(new ProducerRecord<>("throughput-topic", "key-" + i, message));
            }
            System.out.println("1000 messages sent to throughput-topic.");
        }
    }
}

Produsentkomprimering og ACK-er

I tillegg til bunting er det to andre produsentinnstillinger som har stor innvirkning på gjennomstrømmingen:

compression.type: Komprimering av data (for eksempel gzip, snappy og lz4) reduserer bruken av nettverksbåndbredde og diskplass. Dermed kan mer data sendes og lagres, noe som øker den effektive gjennomstrømmingen.
acks: Styrer garantien for varig lagring. acks=0 (fire-and-forget) gir høyest gjennomstrømming, men lavest varighet. acks=1 (lederen bekrefter) gir en god balanse. acks=all (alle replikarer som er synkronisert, bekrefter) gir høyest varighet, men lavest gjennomstrømming.

Skalering av meglere: partisjoner og disker

Kafka-meglere er ryggraden i systemet. Gjennomstrømmingen deres avhenger i stor grad av:

Partisjoner: Hver partisjon i et emne er en ordnet logg. Flere partisjoner gir større grad av parallellitet ved både skriving og lesing av data på tvers av meglere og konsumenter. Fordel partisjonene jevnt mellom meglerne.
Disk-I/O: Kafka bruker diskene intensivt. Bruk av raske SSD-er og konfigurering av RAID 0 eller RAID 10 for datakataloger forbedrer lese- og skrivehastigheten betydelig, noe som er avgjørende for høy gjennomstrømming.

Nettverk og CPU for meglere

Ikke overse den underliggende maskinvaren for meglerne:

Nettverk: Nettverksgrensesnitt med høy hastighet (for eksempel 10-gigabit Ethernet) og tilstrekkelig båndbredde er avgjørende. Meglerne flytter hele tiden data mellom seg (replikering) og mellom seg og klientene.
CPU: Selv om Kafka er optimalisert for sekvensiell disk-I/O, kan CPU-en bli en flaskehals, særlig ved omfattende datakomprimering og -dekomprimering, SSL-kryptering eller komplekse ACL-er. Sørg for tilstrekkelig mange CPU-kjerner.

Optimalisering av konsumenter: bunthenting

Konsumenter har også nytte av bunting. I stedet for å hente én post om gangen henter konsumentene en bunt med poster.

max.poll.records: Maksimalt antall poster som returneres i ett kall til poll(). Ved å behandle flere poster per polling reduseres overheaden fra gjentatte kall.
fetch.min.bytes: Minste datamengde (i byte) som konsumenten venter på å motta fra en megler før den returnerer.
fetch.max.wait.ms: Maksimal tid (i ms) konsumenten venter på at fetch.min.bytes skal oppfylles.

Eksempel på konsument med bunting

En konsument som er konfigurert for bunthenting, henter flere poster per poll()-kall, noe som forbedrer behandlingseffektiviteten.

import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class HighThroughputConsumer {

    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "throughput-group");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        // High throughput settings
        props.put("max.poll.records", 500); // Fetch up to 500 records at once
        props.put("fetch.min.bytes", 1048576); // Wait for 1MB of data
        props.put("fetch.max.wait.ms", 500); // Or wait 500ms

        try (KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props)) {
            consumer.subscribe(Collections.singletonList("throughput-topic"));

            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                if (!records.isEmpty()) {
                    System.out.println("Received " + records.count() + " records.");
                    // Process records (e.g., in a thread pool for parallelism)
                    records.forEach(record -> {
                        // System.out.println("Processing record: " + record.value());
                    });
                    consumer.commitSync();
                }
            }
        }
    }
}

Parallell behandling hos konsumenter

Selv om max.poll.records hjelper med henting, kan selve behandlingen av meldinger bli en flaskehals. Slik maksimerer du konsumentens gjennomstrømming:

Internt trådpool: Implementer et trådpool i konsumentapplikasjonen. Når poll() returnerer en bunt med poster, sender du postene til trådpoolen for parallell behandling.
Forsiktig håndtering av offseter: Ved parallell behandling må du sørge for å bekrefte offseter først etter at alle meldingene i en bunt (eller et bestemt utvalg) er behandlet. Ellers risikerer du datatap eller at meldinger behandles på nytt.

Overvåking av gjennomstrømmingsmålinger

Kontinuerlig overvåking er avgjørende for å identifisere flaskehalser i gjennomstrømmingen. Viktige målinger å følge med på:

Produsent: Forespørselsfrekvens, bytefrekvens og ventetid for forespørsler.
Konsument: Hentefrekvens, bytefrekvens og konsumentetterslep (det viktigste for å identifisere flaskehalser i behandlingen).
Megler: Disk-I/O (lesing/skriving), nettverks-I/O, CPU-utnyttelse og minnebruk.
Nettverk: Utnyttelse av båndbredde og pakketap.

Verktøy som JMX, Prometheus/Grafana eller Confluent Control Center kan hjelpe deg med å visualisere disse målingene.

Utfordring: optimalisering av gjennomstrømming

Du har lært om ulike strategier for å øke gjennomstrømmingen i Kafka-systemer. Hvilke av de følgende handlingene vil vanligvis bidra til å øke den totale gjennomstrømmingen i en datarørledning basert på Kafka?

Besvar den i den interaktive leksjonen

Oppsummering: utforming for gjennomstrømming

Gratulerer! Du har utforsket viktige strategier for å utforme Kafka-baserte systemer som kan håndtere enorme datamengder med høy gjennomstrømming.

Optimaliser produsenter med bunting, komprimering og passende `acks`-innstillinger.
Skaler meglere ved å bruke tilstrekkelig mange partisjoner, raske disker og rikelige nettverks- og CPU-ressurser.
Juster konsumenter med bunthenting, og implementer intern parallellitet for behandlingen.
Overvåk kritiske målinger for å identifisere og håndtere flaskehalser proaktivt.

Det er avgjørende å beherske disse teknikkene for å bygge robuste sanntidsdataplattformer med høy ytelse.

Gratis å komme i gang

Lær deg Grunnleggende Apache Kafka og strømming med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Utforming for høy gjennomstrømming» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Grunnleggende Apache Kafka og strømming, inkludert «Utforming for høy gjennomstrømming», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Grunnleggende Apache Kafka og strømming inneholder totalt 4 leksjoner.

Hva lærer jeg i «Utforming for høy gjennomstrømming»?

Lær arkitektoniske hensyn og anbefalte fremgangsmåter for å bygge Kafka-baserte systemer som håndterer enorme datamengder. Du øver på Grunnleggende Apache Kafka og strømming med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Grunnleggende Apache Kafka og strømming?

Ingen tidligere erfaring er nødvendig. Grunnleggende Apache Kafka og strømming på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Utforming for høy gjennomstrømming»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Grunnleggende Apache Kafka og strømming-leksjonen?

Ja. Alle Grunnleggende Apache Kafka og strømming-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Utforming for høy gjennomstrømming
Katastrofegjenoppretting og georeplikering
Fremtidige trender innen strømbehandling
Backpressure og flytkontroll i stor skala

← Tilbake til Grunnleggende Apache Kafka og strømming