Kraftfull start med Apache Kafka – Installera Kafka 4.2 med CLI och lokala exempel

Apache Kafka 4.2.0 är den aktuella supportade versionslinjen och utgör den bästa grundbulten för en modern snabbstart, eftersom Kafka 4.x helt saknar ZooKeeper och bygger på KRaft som standard.

Den här guiden är en praktisk, terminalbaserad snabbstart: installera Kafka, starta en lokal broker, lär dig de viktigaste Kafka-kommandona och avsluta med två exempel från början till slut som du kan klistra in i din terminal.

Vad Apache Kafka är och vad det används till

Apache Kafka är en plattform för händelseströmning (event streaming). I praktiska termer innebär händelseströmning att fånga händelsedata i realtid från källor (databaser, sensorer, appar), lagra de resulterande strömmarna uthålligt och bearbeta eller routa dem i realtid (eller senare).

Kafka samlar tre kärnfunktioner på en plattform: publisera och prenumerera på strömmar av händelser, lagra strömmar uthålligt så länge det behövs och bearbeta strömmar när de inträffar eller efteråt. Denna kombination är anledningen till att Kafka används för datapipelines i realtid, integration, meddelandehantering och strömanalys.

För sammanhang om var Kafka passar in i en bredare datainfrastruktur, se pelaren Datainfrastruktur för AI-system: Objektlagring, databaser, sökning och AI-dataarkitektur, som täcker S3-kompatibel objektlagring, PostgreSQL-arkitektur, optimering av Elasticsearch och AI-inriktade datalager.

Om du bygger på AWS och behöver ett hanterat alternativ, täcker Bygg händelsestyrda mikrotjänster med AWS Kinesis implementering av händelsestyrda mikrotjänster med Kinesis Data Streams.

Operativt är Kafka ett distribuerat system av servrar och klienter som kommunicerar via ett högpresterande TCP-protokoll: brokers lagrar och serverar data; klienter (producenter och konsumenter) skriver och läser händelser, ofta i stor skala och med felfunktion.

Några begrepp du kommer att se upprepade gånger i kommandotolken:

• Ämnen (Topics) organiserar händelser. Ett ämne är multi-producent och multi-abonnent, och händelser kan läsas flera gånger eftersom behållningstid styr när gamla data kasseras.
• Partitioner fördelar ett ämne över brokers för skalbarhet; ordning garanteras per partition.
• Replikationsfaktor styr felfunktion. Dokumentations exempel rekommenderar oftast replikationsfaktorer på 2 eller 3 i produktion (en en-nodig utvecklingsmiljö använder vanligtvis 1).

Installera Apache Kafka

Kafkas officiella snabbstart använder antingen binärsrelease (tarball) eller den officiella Docker-bilden. Båda är giltiga för lokal utveckling.

Förutsättningar du inte bör hoppa över

Kafka 4.x kräver modern Java: för servern och verktygen är Java 17+ baslinjen för lokal körning, och Kafka 4.0 tog bort stödet för Java 8.

Om du installerar Kafka specifikt för att lära dig, sikta på ett supportat JDK som Java 17 eller 21. Kafkas sidor för Java-stöd listar Java 17, 21 och 25 som fullt supportade, medan Java 11 bara supportas för en delmängd moduler (klienter och strömmar).

Installera från den officiella binärsrelease

Den officiella snabbstarten för Kafka 4.2.0 börjar med att ladda ner och packa upp binärdistributionen:

tar -xzf kafka_2.13-4.2.0.tgz
cd kafka_2.13-4.2.0

Anteckningar för avancerade läsare:

• “2.13” i filnamnet speglar Scala-bygglinjen. För Kafka 4.x-binärer är Scala 2.13 huvudfördelningslinjen, och Kafka 4.0 tog bort stödet för Scala 2.12.
• Om du bryr dig om integriteten i leveranskedjan, dokumenterar nedladdningssidan explicit att du kan verifiera nedladdningar med Apaches publicerade procedurer och KEYS.

Installera med Docker

Kafka tillhandahåller också officiella Docker-bilder på Docker Hub. Snabbstarten visar att du kan hämta och köra Kafka 4.2.0 så här:

docker pull apache/kafka:4.2.0
docker run -p 9092:9092 apache/kafka:4.2.0

Det finns också en “nativ” bildslinje (baserad på GraalVM native image). Kafkadokumentationen och Kafka Improvement Proposal för denna bildslinje beskriver den som experimentell och avsedd för lokal utveckling och testning, inte produktion.

Plattformsnote för Windows-användare

Kafkadistributioner inkluderar Windows-skript (batchfiler). Kafkadokumentationen noterar historiskt att på Windows använder du bin\windows\ och .bat-skript istället för Unix bin/ .sh-skript.

Starta Kafka lokalt med KRaft

Om du frågar “Behöver jag ZooKeeper för att köra Apache Kafka”, är det moderna svaret nej. Kafka 4.0 är den första större release som är utformad för att fungera helt utan ZooKeeper, och kör i KRaft-läge som standard, vilket minskar den operativa belastningen för både lokal och produktionsbruk.

Starta en en-nodig lokal broker från den utpackade tarballen

Kafkas 4.2 snabbstart använder tre kommandon:

1. Generera en cluster-ID
2. Formatera loggkatalogerna
3. Starta servern

# Generera en Cluster UUID
KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"

# Formatera Loggkataloger (lokal enskild format)
bin/kafka-storage.sh format --standalone -t "$KAFKA_CLUSTER_ID" -c config/server.properties

# Starta Kafka-brokern
bin/kafka-server-start.sh config/server.properties

Varför “format”-steget är viktigt i KRaft: Kafkas dokumentation för KRaft-operationer förklarar att kafka-storage.sh random-uuid genererar cluster-ID:n och att varje server måste formateras med kafka-storage.sh format. En anledning som ges är att automatisk formatering kan dölja fel, särskilt kring metadata-loggen, så explicit formatering är att föredra.

Vad du kör i denna snabbstart

För lokal utveckling kan Kafka köras i en förenklad “kombinerad” konfiguration (kontroller och brokers tillsammans). Kafkas KRaft-dokumentation pekar på kombinerade servrar som enklare för utveckling men inte rekommenderade för kritiska implementeringsmiljöer (där du vill att kontrollerna ska vara isolerade och skalbara oberoende).

För “riktiga” kluster är KRaft-kontroller och brokers separata roller (process.roles), och kontroller implementeras vanligtvis som en quorum på 3 eller 5 noder (tillgänglighet beror på att en majoritet är levande).

Kafka CLI-essentiella och huvudkommandoparametrar

Kafka levereras med mycket CLI-verktyg under bin/. De officiella operationsdokumenten betonar två användbara egenskaper:

• De vanliga verktygen finns under distributionens bin/-katalog.
• Varje verktyg skriver ut sin fullständiga kommandolinjeanvändning när det körs utan argument.

Även viktigt för Kafka 4.x: AdminClient-kommandon accepterar inte längre --zookeeper. Kafkas kompatibilitetsdokumentation noterar att från och med Kafka 4.0 måste du använda --bootstrap-server för att interagera med klustret.

Kafka-anslutningsflaggor du kommer att använda ständigt

De flesta verktyg behöver en klusteringspunkt:

• --bootstrap-server host:port
  Använd detta för ämnesoperationer, konsumentgrupper och de flesta broker-inriktade kommandon. Det är den kanoniska ersättningen för ZooKeeper-baserade administrationsarbetsflöden i Kafka 4.x.

KRaft introducerar broker- kontra kontroller-endpoints för vissa verktyg. Till exempel kan kafka-features.sh och delar av metadata-verktygen använda kontroller-endpoints, medan många administrationsoperationer använder broker-endpoints. Sidan för KRaft-operationer visar båda stilarna i exempel.

Ämneshantering med kafka-topics.sh

Du kommer att använda kafka-topics.sh för den kärnlivscykeln:

• Skapa, beskriv och lista ämnen (snabbstarten visar --create, --describe, --topic).
• Specificera skala och uthållighet via partitioner och replikationsfaktor. Operationsguiden visar --partitions och --replication-factor och förklarar hur de påverkar skalbarhet och felfunktion.
• Lägg till per-ämnes-överstyrelse vid skapning med --config key=value (ämnets konfigurationsdokument visar konkreta exempel).

Ett bra “produktionsinriktat” skapningskommando ser ut så här (exakt denna form används i de officiella operationsdokumenten):

bin/kafka-topics.sh --bootstrap-server localhost:9092 \
  --create --topic my_topic_name \
  --partitions 20 --replication-factor 3 \
  --config x=y

Producerar och konsumerar med konsolklienter

Snabbstarten använder konsolproducenten och konsumenten eftersom de är snabba för validering och röktest:

• kafka-console-producer.sh --topic ... --bootstrap-server ...
• kafka-console-consumer.sh --topic ... --from-beginning --bootstrap-server ...

Kafka 4.2 inkluderar också förbättringar av CLI-konsistens. I uppdateringsanteckningarna:

• kafka-console-producer depreciterar --max-partition-memory-bytes och rekommenderar --batch-size istället.
• kafka-console-consumer depreciterar --property (formatter-egenskaper) till förmån för --formatter-property.
• kafka-console-producer depreciterar --property (meddelandeläsaregenskaper) till förmån för --reader-property.

Om du underhåller interna arbetsrutiner är dessa anteckningar värda att uppdatera nu, innan Kafka 5.0 tar bort de deprimerade flaggorna.

Inspektera konsumentlag med kafka-consumer-groups.sh

För verkliga system är “Håller min konsument med?” en daglig fråga. Operationsguiden demonstrerar:

• Lista grupper: --list
• Beskriv en grupp med offset och lag: --describe --group ...
• Beskriv medlemmar och tilldelningar: --members och --verbose
• Radera grupper: --delete
• Återställ offset säkert: --reset-offsets

Exempel:

bin/kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group my-group

En konfigurationsfälla för lokal Docker och fjärrklienter

Om du kör Kafka i behållare eller bakom lastbalanserare kommer du så småningom att behöva ställa in lyssnare korrekt. Kafkas brokerkonfigurationsdokument förklarar advertised.listeners som de adresser som brokers annonserar till klienter och andra brokers, särskilt när bindningsadressen inte är adressen som klienter bör använda.

Snabbstartsexempel du kan köra nu

Exemplen nedan är medvetet terminalbaserade så att du kan validera en lokal Kafka-installation innan du skriver någon applikationskod.

Exempel: kör ett ämne och strömma meddelanden från början till slut

Detta är den kanoniska “skapa, producera, konsumera”-flödet från Kafkas 4.2 snabbstart.

Öppna terminal A och skapa ett ämne:

bin/kafka-topics.sh --create --topic quickstart-events --bootstrap-server localhost:9092

Beskriv det nu (valfritt men användbart när du lär dig partitioner och replikationsfaktor):

bin/kafka-topics.sh --describe --topic quickstart-events --bootstrap-server localhost:9092

Öppna terminal B och starta en producent:

bin/kafka-console-producer.sh --topic quickstart-events --bootstrap-server localhost:9092

Skriv ett par rader (varje rad blir en händelse), och låt producenten köra:

This is my first event
This is my second event

Öppna terminal C och starta en konsument från början:

bin/kafka-console-consumer.sh --topic quickstart-events --from-beginning --bootstrap-server localhost:9092

Du bör se samma rader skrivna ut.

Varför detta validerar mer än “det fungerar”: Kafkas snabbstart förklarar att brokers lagrar händelser uthålligt och att händelser kan läsas flera gånger och av flera konsumenter. Denna uthållighet är anledningen till att detta snabbstartsmönster är det första du bör göra efter någon installation eller uppgradering.

Exempel: kör en enkel Kafka Connect-pipeline från fil till ämne till fil

Kafka Connect svarar på den återkommande frågan “Hur flyttar jag data in och ut ur Kafka utan att skriva anpassade producenter och konsumenter för allt”. Översikten över Kafka Connect beskriver den som ett verktyg för skalbar och pålitlig strömning mellan Kafka och andra system via anslutningsmoduler (connectors).

Kafkas 4.2 snabbstart inkluderar en minimal, lokal Connect-demo med hjälp av filkäll- och filsink-anslutningsmoduler.

Från din Kafka-katalog, sätt först arbetsmaskinens plugin-sökväg för att inkludera den medlevererade filanslutningsmodulens jar:

echo "plugin.path=libs/connect-file-4.2.0.jar" >> config/connect-standalone.properties

Skapa en liten inmatningsfil:

echo -e "foo\nbar" > test.txt

Starta Connect-arbetaren i enskilt läge med både en käll- och en sink-konfiguration:

bin/connect-standalone.sh \
  config/connect-standalone.properties \
  config/connect-file-source.properties \
  config/connect-file-sink.properties

Vad som bör hända (och varför det är användbart):

• Källanslutningsmodulen läser rader från test.txt och producerar dem till ämnet connect-test.
• Sink-anslutningsmodulen läser från connect-test och skriver till test.sink.txt.

Verifiera sink-filen:

more test.sink.txt

Du bör se:

foo
bar

Du kan också verifiera ämnet direkt:

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic connect-test --from-beginning

Detta andra exempel är en utmärkt byggnad av muskelminne eftersom det också lär dig var Connect-konfigurationen sitter (arbetsmaskinskfiguration plus anslutningsmodulkonfigurationer) och visar en minimal “inlämna, lagra, exportera”-loop.

felsökning och nästa steg

De flesta “Kafka Snabbstart startar inte”-problem faller in i en liten uppsättning orsaker.

Brokern startar inte

Börja med de officiella kraven:

• Kafka 4.2 Snabbstart kräver explicit Java 17+. Om du har ett äldre JDK, åtgärda det först.
• I KRaft-läge är formatering av lagring ett obligatoriskt explicit steg. Om du hoppar över kafka-storage.sh format kommer du sannolikt att se startfel eller metadatafel.

Om du experimenterat och nu vill ha en ren start, visar Kafkas snabbstart hur du raderar de lokala datakataloger som används i demot:

rm -rf /tmp/kafka-logs /tmp/kraft-combined-logs

CLI-kommandon misslyckas trots att brokern körs

I Kafka 4.x, validera att du använder --bootstrap-server (inte --zookeeper). Kafkas kompatibilitetsdokumentation pekar explicit ut borttagningen av --zookeeper från AdminClient-kommandon från och med Kafka 4.0.

Docker-nätverksöverraskningar

Om Kafka är i Docker och ditt klientverktyg utanför Docker (eller på en annan maskin), kan du behöva korrekt annonsering av lyssnare. Brokerkonfigurationsdokumenten förklarar att advertised.listeners används när adresserna som klienter bör ansluta till skiljer sig från bindningsadresserna (listeners).

Var du ska gå efter snabbstarten

Om du har slutfört exemplen i detta inlägg har du redan besvarat de vanligaste första sökfrågorna:

• vad Kafka används till (händelseströmning från början till slut)
• hur man installerar Kafka lokalt (tarball eller Docker)
• varför ZooKeeper är borta och KRaft är standard i 4.x
• vilka CLI-verktyg som är viktiga dagligen (ämnen, producent, konsument, grupper)

Härifrån är de mest värdefulla nästa stegen vanligtvis:

• Läs Kafkas “Introduction” för djupare mentala modeller av ämnen, partitioner och replikering.
• Utforska Kafka Streams Quick Start om du vill ha ett första bearbetningsprogram (Streams Quickstart demonstrerar körning av WordCount-demo och inspektion av resultat med konsolkonsumenten).