Grunderna i Apache Kafka och strömbearbetning · Lektion

Producera meddelanden till Kafka

Utforska hur ni skriver applikationer som effektivt och tillförlitligt skickar data till Kafka-topics.

Lektion 1 av 412 steg

Producera meddelanden till Kafka är en gratis lektion i Grunderna i Apache Kafka och strömbearbetning på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Grunderna i Apache Kafka och strömbearbetning, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Grunderna i Apache Kafka och strömbearbetning innehåller totalt 4 lektioner.

Möt Kafka-producenten

I den här lektionen lär ni er hur man skickar meddelanden (även kallade poster) till Kafka-topics. Det är en Kafka-producents uppgift.

Tänk på en producent som en applikation eller tjänst som genererar data. Den skickar sedan dessa data till ett Kafka-kluster, där de lagras i specifika topics så att andra applikationer kan läsa dem.

Producenter genererar data.
Topics organiserar dataströmmar.
Brokers lagrar data.

Grunderna i producentklienten

För att skicka data använder applikationen ett Kafka Producer-klientbibliotek. Biblioteket hanterar alla komplexa interaktioner med Kafka-brokers.

Det tar hand om följande:

Hitta rätt Kafka-broker.
Serialisera era data till byte.
Försöka skicka igen när en sändning misslyckas.
Balansera distributionen av meddelanden.

Vi använder Java-exempel, men koncepten gäller för flera språk.

Viktig producentkonfiguration

Innan en producent kan skicka meddelanden behöver den en grundläggande konfiguration. De två viktigaste inställningarna är:

bootstrap.servers: En kommaseparerad lista med värd- och portpar för Kafka-brokers. Producenten använder dessa för att hitta hela klustret.
key.serializer och value.serializer: Klasser som omvandlar meddelandets nyckel- och värdeobjekt till bytearrayer, vilket är det format Kafka använder för att lagra data.

Utan dessa vet producenten inte vart meddelanden ska skickas eller hur de ska formateras.

Exempel på producentkonfiguration

Så här kan ni konfigurera dessa egenskaper i Java:

import java.util.Properties;

public class ProducerConfigDemo {
  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");

    System.out.println("Producer properties configured!");
    // In a real app, you'd create a KafkaProducer with these props
  }
}

Skapa ert meddelande: ProducerRecord

När ni skickar data till Kafka skickar ni inte bara en sträng. Ni skickar en ProducerRecord. Detta objekt kapslar in meddelandet och dess metadata.

En ProducerRecord kräver följande:

Namnet på den topic dit meddelandet ska skickas.
En valfri nyckel: används för att partitionera meddelanden. Meddelanden med samma nyckel hamnar i samma partition.
Värdet: de faktiska data ni vill skicka.

Nycklar är viktiga för att säkerställa ordningen för relaterade data inom en topic.

Skicka meddelanden (blockerande)

Det enklaste sättet att skicka ett meddelande är att använda metoden send(). Om ni vill vänta på att Kafka bekräftar meddelandet kan ni anropa .get() på det returnerade objektet Future.

Detta gör sändningen synkron (blockerande). Det är enkelt att förstå, men kan gå långsamt om ni skickar många meddelanden.

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

public class SyncProducer {
  public static void main(String[] args) throws Exception {
    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");

    try (KafkaProducer<String, String> producer = new KafkaProducer<>(props)) {
      ProducerRecord<String, String> record = new ProducerRecord<>(
        "my-topic", "key1", "Hello Sync Kafka!");
      
      RecordMetadata metadata = producer.send(record).get(); // Blocks here
      System.out.println("Sent message: " + metadata.topic() + "-" + metadata.partition());
    }
  }
}

Skicka meddelanden (icke-blockerande)

För bättre prestanda är Kafka-producenter utformade för att skicka meddelanden asynkront. När ni anropar send() läggs meddelandet till i en buffert och metoden returnerar omedelbart.

Den faktiska sändningen sker i bakgrunden. Det gör att applikationen kan fortsätta bearbeta data utan att vänta på att varje meddelande ska levereras.

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

public class AsyncProducer {
  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");

    try (KafkaProducer<String, String> producer = new KafkaProducer<>(props)) {
      ProducerRecord<String, String> record = new ProducerRecord<>(
        "my-topic", "key2", "Hello Async Kafka!");
      
      producer.send(record); // Returns immediately
      System.out.println("Message queued for sending.");
      // In a real app, you'd send many messages here
    }
  }
}

Hantera sändningsresultat med callbacks

Eftersom send() är asynkron, hur vet ni om ett meddelande skickades eller om ett fel uppstod? Ni använder en Callback.

Callback-funktionen körs när Kafka har bekräftat meddelandet eller när ett fel hindrar det från att skickas. Detta är avgörande för felhantering och loggning.

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

public class CallbackProducer {
  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");

    try (KafkaProducer<String, String> producer = new KafkaProducer<>(props)) {
      ProducerRecord<String, String> record = new ProducerRecord<>(
        "my-topic", "key3", "Hello Callback Kafka!");
      
      producer.send(record, new Callback() {
        @Override
        public void onCompletion(RecordMetadata metadata, Exception exception) {
          if (exception == null) {
            System.out.println("Message sent successfully to topic " + metadata.topic());
          } else {
            System.err.println("Error sending message: " + exception.getMessage());
          }
        }
      });
      // Must flush or close producer to ensure callback is triggered in short programs
      producer.flush(); 
    }
  }
}

Säkerställ leverans: konfiguration av acks

Producentens tillförlitlighet styrs av konfigurationen acks. Denna inställning avgör hur många bekräftelser producenten behöver från Kafka-brokers innan ett meddelande anses vara ”skickat”.

acks=0: Producenten skickar utan att invänta någon bekräftelse. Snabbast, men med lägst beständighet (meddelanden kan gå förlorade).
acks=1: Producenten väntar på att leader-brokern ska bekräfta mottagandet. En bra balans mellan hastighet och beständighet.
acks=all (eller -1): Producenten väntar på bekräftelse från alla synkroniserade repliker. Långsammast, men med högst beständighet (det är mycket osannolikt att meddelanden går förlorade).

Bästa praxis för producenter

Så här säkerställer ni att era Kafka-producenter är effektiva och robusta:

Stäng alltid producenten: anropa producer.close() när applikationen stängs av. Det tömmer eventuella buffrade meddelanden och frigör resurser.
Batchning: Kafka-producenter batchar automatiskt meddelanden för bättre effektivitet. Ni kan justera linger.ms och batch.size för optimal genomströmning.
Felhantering: implementera robust felhantering i era callbacks för att hantera tillfälliga nätverksproblem eller permanenta fel.

Rätt konfiguration och resurshantering är avgörande för en välfungerande Kafka-applikation.

Snabb kontroll: producenter

Vilken producentegenskap anger hur många bekräftelser producenten behöver från Kafka-brokers innan ett meddelande anses vara skickat?

Besvara frågan i den interaktiva lektionen

Sammanfattning av producenter

Ni har lärt er grunderna i att producera meddelanden till Kafka!

Producenter skickar data till topics.
Viktiga konfigurationer är bland annat bootstrap.servers och serialiserare.
Meddelanden kapslas in i objekt av typen ProducerRecord.
Ni kan skicka meddelanden synkront (blockerande) eller asynkront (icke-blockerande).
Callbacks används för att hantera resultat från asynkrona sändningar.
Inställningen acks styr meddelandenas beständighet.

Nästa steg är att gå igenom hur applikationer läser dessa meddelanden med Kafka Consumers!

Gratis att börja

Lär dig Grunderna i Apache Kafka och strömbearbetning med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Producera meddelanden till Kafka” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Grunderna i Apache Kafka och strömbearbetning, inklusive ”Producera meddelanden till Kafka”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Grunderna i Apache Kafka och strömbearbetning innehåller totalt 4 lektioner.

Vad lär jag mig i ”Producera meddelanden till Kafka”?

Utforska hur ni skriver applikationer som effektivt och tillförlitligt skickar data till Kafka-topics. Ni övar på Grunderna i Apache Kafka och strömbearbetning med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Grunderna i Apache Kafka och strömbearbetning?

Du behöver inga förkunskaper. Utbildningen i Grunderna i Apache Kafka och strömbearbetning på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Producera meddelanden till Kafka”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Grunderna i Apache Kafka och strömbearbetning-lektionen?

Ja. Varje Grunderna i Apache Kafka och strömbearbetning-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Producera meddelanden till Kafka
Konsumera meddelanden från Kafka
Förstå partitioner och offsetar
Meddelandenycklar och partitioneringsstrategier

← Tillbaka till Grunderna i Apache Kafka och strömbearbetning