Apache Kafka-quickstart – Installera Kafka 4.2 med CLI och lokala exempel

Apache Kafka 4.2.0 är den aktuellt supportade versionslinjen, och den utgör den bästa grunden för en modern snabbstart eftersom Kafka 4.x är helt fri från ZooKeeper och byggs kring KRaft som standard.

Denna guide är en praktisk snabbstart med fokus på kommandoraden: installation av Kafka, start av en lokal broker, lärande av de essentiella Kafka-kommandotolken (CLI) och avslutning 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 för

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

Kafka kombinerar tre kärnfunktioner i en plattform: publicera och prenumerera på strömmar av händelser, lagra strömmar beståndssäkert så länge som behövs, och bearbeta strömmar när de inträffar eller i efterhand. Denna kombination är anledningen till att Kafka används för datapipelines i realtid, integration, meddelandehantering och strömanalys.

För sammanhang kring var Kafka passar in i en bredare datainfrastruktur, se pelaren Data Infrastructure for AI Systems: Object Storage, Databases, Search & AI Data Architecture, som täcker objektstorage kompatibel med S3, PostgreSQL-arkitektur, Elasticsearch-optimering och AI-inriktade datalager.

Om du bygger på AWS och behöver en hanterad alternativ, täcker Building Event-Driven Microservices with AWS Kinesis implementering av händelsedrivrna mikrotjänster med Kinesis Data Streams.

För statsträffad strömbearbetning med Kafka, se Apache Flink on K8s and Kafka: PyFlink, Go, ops, and managed pricing.

För tjänster som skriver till en databas innan de publicerar till Kafka, säkerställer transactional outbox pattern att händelser aldrig förloras mellan databascommit och Kafka-producer-anropet.

Operativt sett är Kafka ett distribuerat system av servrar 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 feltolerans.

Få koncept du kommer att se upprepade gånger i kommandotolken:

• Ämnen (Topics) organiserar händelser. Ett ämne är multi-producer och multi-abonnent, och händelser kan läsas flera gånger eftersom retention kontrollerar när gamla data kasseras.
• Partitioner shardar ett ämne över brokers för skalbarhet; ordning garanteras per partition.
• Replikationsfaktor kontrollerar feltolerans. Dokumentationsexempel rekommenderar vanligtvis replikationsfaktorer på 2 eller 3 i produktion (en enhetsnod-utvecklings-snabbstart använder typiskt 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 bör inte 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 det, sikta på en supportad JDK såsom Java 17 eller 21. Kafkas Java-stödsida listar Java 17, 21 och 25 som fullt supportade, medan Java 11 endast stöds för en delmängd av moduler (klienter och strömmar).

Installera från den officiella binärutgå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

Noteringar för avancerade läsare:

• “2.13” i filnamnet avspeglar Scala-byggnadslinjen. För Kafka 4.x-binärer är Scala 2.13 primära distributionslinjen, och Kafka 4.0 tog bort stöd för Scala 2.12.
• Om du bryr dig om leveranskedjans integritet, dokumenterar nedladdningssidan explicit att du kan verifiera nedladdningar med hjälp av 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 på detta sätt:

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

Det finns även en “native” 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 test, inte produktion.

Plattformsnote för Windows-användare

Kafka-distributioner inkluderar Windows-skript (batchfiler). Kafkas dokumentation noterar historiskt att på Windows använder du bin\windows\ och .bat-skript snarare än 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 operera helt utan ZooKeeper, som körs i KRaft-läge som standard, vilket minskar den operativa bördan för lokal och produktionsanvändning.

Starta en lokal enhetsnod-broker från den extraherade tarballen

Kafkas 4.2-snabbstart använder tre kommandon:

1. Generera en kluster-UUID
2. Formatera loggkatalogerna
3. Starta servern

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

# Formatera Loggkataloger (standalone lokal 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 kluster-ID:t och att varje server måste formateras med kafka-storage.sh format. En given rationalisering är att automatisk formatering kan dölja fel, särskilt kring metadata-loggen, så explicit formatering föredras.

Vad du kör i denna snabbstart

För lokal utveckling kan Kafka köras i en förenklad “kombinerad” uppställning (kontroller och brokers tillsammans). Kafkas KRaft-dokumentation lyfter fram kombinerade servrar som enklare för utveckling men inte rekommenderade för kritiska distributionsmiljö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 av 3 eller 5 noder (tillgängligheten beror på att en majoritet är levande).

Kafka CLI-essentiellkunskap och huvudkommandoradsparametrar

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

• De gemensamma verktygen finns under distributionens bin/-katalog.
• Varje verktyg skriver ut sin fullständiga kommandoradsanvä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, du måste 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ångspunkt:

• --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 admin-arbetsflöden i Kafka 4.x.

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

Ämneshantering med kafka-topics.sh

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

• Skapa, beskriva, lista ämnen (Snabbstarten visar --create, --describe, --topic).
• Specificera skala och beståndssäkerhet via partitioner och replikationsfaktor. Operationsguiden visar --partitions och --replication-factor och förklarar hur de påverkar skalbarhet och feltolerans.
• Lägg till per-ämne-återställningar vid skapningstid med --config key=value (ämneskonfigurationsdokumentationen visar konkreta exempel).

Ett bra “produktionsinriktat” skapandekommando 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 konsol-klienter

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å konsistensförbättringar i kommandotolken. I uppgraderingsnoterna:

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

Om du underhåller interna runbooks är dessa noteringar värda att uppdatera nu, innan Kafka 5.0 tar bort de deprecierade flaggorna.

Inspektera konsumentlag med kafka-consumer-groups.sh

För riktiga system är “Hänger 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ällan för lokal Docker och fjärrklienter

Om du kör Kafka i containrar eller bakom lastbalanserare, kommer du attändra behöva ställa in lyssnare korrekt. Kafkas broker-konfigurationsdokument förklarar advertised.listeners som de adresser brokers annonserar till klienter och andra brokers, särskilt när bind-adressen inte är adressen klienter bör använda.

Snabbstartsexempel du kan köra nu

Exemplen nedan är avsiktligt baserade på kommandotolken så att du kan validera en lokal Kafka-uppställning innan du skriver någon applikationskod.

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

Detta är det kanoniska flödet “skapa, producera, konsumera” från Kafka 4.2-snabbstarten.

Ö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 några rader (varje rad blir en händelse), och låt sedan 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 att “det fungerar”: Kafkas snabbstart förklarar att brokers lagrar händelser beståndssäkert och att händelser kan läsas flera gånger och av flera konsumenter. Denna beståndssäkerhet är anledningen till att detta snabbstartsmönster är det första du bör göra efter 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”. Kafka Connect-översikten beskriver det som ett verktyg för skalbar, pålitlig strömning mellan Kafka och andra system, via connectorns.

Kafka 4.2-snabbstarten inkluderar en minimal, lokal Connect-demo med hjälp av file source och sink-connectorns.

Från din Kafka-katalog, sätt först worker-plugin-vägen för att inkludera den medföljande file connector-jar-filen:

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

Skapa en liten indatafil:

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

Starta Connect-workern i standalone-läge med både en source och sink connector-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):

• Source-connectorn läser rader från test.txt och producerar dem till ämnet connect-test.
• Sink-connectorn 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 muskelminnesbyggare eftersom det också lär dig var Connect-konfigurationen sitter (worker-konfiguration plus connector-konfigurationer) och visar en minimal “inhämta, lagra, exportera”-loop.

Felsökning och nästa steg

De flesta “Kafka Snabbstart startar inte”-problem faller in i ett litet antal rotorsaker.

Broker misslyckas med att starta

Börja med de officiella kraven:

• Kafka 4.2-snabbstarten 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 troligtvis att se startfel eller metadata-fel.

Om du experimenterat och nu vill ha en ren blankett, 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 även om brokern körs

I Kafka 4.x, validera att du använder --bootstrap-server (inte --zookeeper). Kafkas kompatibilitetsdokumentation lyfter explicit fram 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 är utanför Docker (eller på en annan maskin), kan du behöva korrekt lyssnareannonsering. Broker-konfigurationsdokumenten förklarar att advertised.listeners används när adresserna klienter bör ansluta till skiljer sig från bind-adresserna (listeners).

Var att gå efter snabbstarten

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

• 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 standard i 4.x
• vilka CLI-verktyg är viktiga dag till 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 Quick Start om du vill ha ett första bearbetningsapplikation (Streams Quickstart demonstrerar att köra WordCount-demon och inspektera resultat med konsolkonsumenten).