Apache Kafka Snabbstart – Installera Kafka 4.2 med CLI och lokala exempel

Apache Kafka 4.2.0 är den aktuella supportade utgåvelinjen, och den utgör den bästa basen för ett modernt snabbstartsguide eftersom Kafka 4.x är helt utan ZooKeeper och bygger på KRaft som standard.

Denna guide är en praktisk, kommandoradsförst snabbstart: installation av Kafka, start av en lokal broker, lärande om de essentiella CLI-verktygen för Kafka, och avslutning med två slutna exempel som du kan klistra in i din terminal.

Vad Apache Kafka är och vad det används för

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

Kafka samlar tre kärnfunktioner i en plattform: publisera och prenumerera på strömmar av händelser, lagra strömmar beständigt så länge som behövs, och bearbeta strömmar när de inträffar eller i efterhand. Det är denna kombination som gör att Kafka används för realtids datapipelines, integration, meddelandehantering och strömbaserad analys.

För kontext kring 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, Elasticsearch-optimering och AI-innativa dataskikt.

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

För tillståndsfull strömbearbetning med Kafka, se Apache Flink på K8s och Kafka: PyFlink, Go, ops och hanterad prissättning.

Operationellt sett är Kafka ett distribuerat system av server och klienter som kommunicerar över 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 felhantering.

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

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

Installera Apache Kafka

Kafkas officiella snabbstart använder binärutgåvan (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öd för Java 8.

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

Installera från den officiella binära utgåvan

Den officiella snabbstarten för Kafka 4.2.0 börjar med att ladda ner och extrahera den binära distributionen:

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öd för Scala 2.12.
• Om du bryr dig om integritet 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 dra 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” bildlinje (baserad på GraalVM native image). Kafkas dokumentation och Kafka Improvement Proposal för denna bildlinje beskriver den som experimentell och avsedd för lokal utveckling och testning, inte produktion.

Plattformsnote för Windows-användare

Kafka-distributioner 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 stora utgåvan som är designad 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 produktionsanvändning.

Starta en lokal broker med en enda nod från den extraherade tarballen

Kafkas 4.2 snabbstart använder tre kommandon:

1. Generera ett kluster-ID
2. Forma loggkatalogerna
3. Starta servern

# Generera ett kluster-ID
KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"

# Forma loggkatalogerna (enkelt lokalt 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 om KRaft-operationer förklarar att kafka-storage.sh random-uuid genererar kluster-ID:t och att varje server måste formateras med kafka-storage.sh format. En av de givna orsakerna ä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 ett förenklat “kombinerat” setup (kontroller och brokers tillsammans). Kafkas KRaft-dokumentation pekar ut kombinerade servrar som enklare för utveckling men inte rekommenderad för kritiska driftsmiljöer (där du vill att kontroller ska vara isolerade och skalbara oberoende).

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

Väsentliga CLI-verktyg och huvudsakliga kommandoradsparametrar för Kafka

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

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

Också 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 kluster-ingång:

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

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

Ämneshantering med kafka-topics.sh

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

• Skapa, beskriv, lista ämnen (Snabbstarten visar --create, --describe, --topic).
• Specificera skala och beständighet via partitioner och replikationsfaktor. Operationsguiden visar --partitions och --replication-factor och förklarar hur de påverkar skalbarhet och felhantering.
• Lägg till per-ämne-överstyrelser 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

Producera och konsumera med konsolklienter

Snabbstarten använder konsolproducenten och konsolkonsumenten 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 uppgraderingsnoteringarna:

• kafka-console-producer avvecklar --max-partition-memory-bytes och rekommenderar --batch-size istället.
• kafka-console-consumer avvecklar --property (formateringsattribut) till förmån för --formatter-property.
• kafka-console-producer avvecklar --property (meddelande-läsareattribut) till förmån för --reader-property.

Om du underhåller interna körböcker, är dessa anteckningar värda att uppdatera nu, innan Kafka 5.0 tar bort de avvecklade flaggorna.

Inspektera konsumentförsening med kafka-consumer-groups.sh

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

• Lista grupper: --list
• Beskriv en grupp med offset och försening: --describe --group ...
• Beskriv medlemmar och tilldelningar: --members och --verbose
• Ta bort grupper: --delete
• Sätt om offset säkert: --reset-offsets

Exempel:

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

En konfigurationsvarning för lokal Docker och fjärrklienter

Om du kör Kafka i containrar eller bakom lastbalanserare, kommer du så småningom att stöta på behovet att sätta lyssnare korrekt. Kafkas brokerkonfigurationsdokument förklarar advertised.listeners som de adresser brokers annonserar till klienter och andra brokers, särskilt när bindadressen inte är adressen klienterna bör använda.

Snabbstartsexempel du kan köra nu

Exemplen nedan är medvetet kommandoradsbaserade så att du kan validera en lokal Kafka-setup 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ämna producenten körande:

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.

Varför detta validerar mer än att det “fungerar”: Kafkas snabbstart förklarar att brokers lagrar händelser beständigt och att händelser kan läsas flera gånger och av flera konsumenter. Det är denna beständighet som gör att detta snabbstartsmönster är det första du bör göra efter varje 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 från Kafka utan att skriva anpassade producenter och konsumenter för allt”. Kafkas Connect-översikt beskriver den som ett verktyg för skalbar, pålitlig strömning mellan Kafka och andra system, via kopplingsmoduler (connectors).

Kafkas 4.2 snabbstart inkluderar en minimal, lokal Connect-demo som använder fil-kopplingsmoduler för källa och mottagare.

Från din Kafka-katalog, sätt först arbetsmodulens plugin-väg för att inkludera den medföljande fil-kopplingsmodulens 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 standalone-läge med både en käll- och mottagarkopplingsmodul-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ällkopplingsmodulen läser rader från test.txt och producerar dem till ämnet connect-test.
• Mottagarkopplingsmodulen läser från connect-test och skriver till test.sink.txt.

Verifiera mottagarfilen:

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 muskelminnesbygger eftersom det också lär dig var Connect-konfigurationen sitter (arbetsmodulskonfiguration plus kopplingsmodulskonfigurationer) och visar en minimal “importera, lagra, exportera”-loop.

Felsökning och nästa steg

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

Broker misslyckas med att starta

Börja med de officiella kraven:

• Kafkas 4.2 snabbstart kräver explicit Java 17+. Om du är på en äldre JDK, fixa 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 tar bort de lokala datakataloger som används i demon:

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

CLI-kommandon misslyckas även om brokern körs

I Kafka 4.x, validera att du använder --bootstrap-server (inte --zookeeper). Kafkas kompatibilitetsdokumentation pekar ut explicit borttagandet 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 är 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 de adresser klienterna bör ansluta till skiljer sig från bindadresserna (listeners).

Vart du ska gå efter snabbstarten

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

• vad Kafka används för (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 standarden i 4.x
• vilka CLI-verktyg som spelar roll dag för dag (ä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 Snabbstart om du vill ha en första bearbetningsapplikation (Streams-snabbstarten demonstrerar körning av WordCount-demon och inspektion av resultat med konsolkonsumenten).