【Kafka系列·入门第四篇】Kafka实操入门：环境部署（Windows/Linux）+ 简单消息收发

大家好，接续上一篇《Kafka核心概念全解析：Topic、Partition、Replica与Consumer Group》，今天我们正式从"理论"走向"实操"------手把手教你完成Kafka环境部署，以及简单的消息收发操作。

上一篇我们吃透了Kafka的四大核心概念，搞懂了Topic、Partition、Replica、Consumer Group的作用和关联关系，这是我们实操的基础。对于新手来说，光懂理论远远不够，只有亲手部署环境、发送和接收消息，才能真正理解Kafka的工作流程，也能为后续的进阶学习（如集群部署、故障排查）打下实操基础。

本文将分为两大核心部分：第一部分是Kafka单机版环境部署，分别讲解Windows和Linux两种常用环境的部署步骤，每一步都标注清晰、避开坑点，新手也能轻松跟着操作；第二部分是简单消息收发实操，通过命令行和Java代码两种方式，实现生产者发送消息、消费者接收消息，让你直观感受Kafka的消息传递流程。

全程避开晦涩的底层源码和复杂配置，只讲新手必学、必用的实操内容，步骤清晰、可落地，跟着操作就能完成所有实操任务。

一、前置准备：明确部署核心依赖

在部署Kafka之前，我们需要先明确一个核心依赖------Kafka依赖Java环境（JDK），因为Kafka本身是基于Java开发的。无论Windows还是Linux环境，都需要先安装并配置好JDK，否则Kafka无法启动。

1. JDK安装要求

版本要求：推荐JDK 1.8及以上（兼容性最好，避免高版本出现兼容问题）；
核心注意：安装后必须配置环境变量（JAVA_HOME），否则Kafka无法识别JDK路径；
验证方法：打开命令行（Windows cmd/ Linux终端），输入"java -version"，若能显示JDK版本信息，说明JDK安装配置成功。

2. Kafka版本选择

推荐版本：Apache Kafka 2.8.0及以上（稳定版，支持KRaft模式，无需依赖ZooKeeper，新手更易部署）；
下载地址：Apache Kafka官方下载地址（https://kafka.apache.org/downloads），选择对应系统的二进制包（Binary downloads），无需下载源码包（源码包需要编译，新手不推荐）。

补充：Kafka 2.8.0之前的版本，必须依赖ZooKeeper管理集群元数据，部署相对复杂；2.8.0及以上版本支持KRaft模式（无ZooKeeper模式），单机部署时无需额外部署ZooKeeper，大幅简化部署步骤，本文将以"无ZooKeeper模式"为例，讲解部署流程。

二、Kafka单机版部署（Windows环境，新手首选）

Windows环境操作直观、适合新手，我们先讲解Windows环境的部署步骤，每一步都标注详细操作和注意事项，避开新手常踩的坑。

步骤1：下载并解压Kafka安装包

访问Apache Kafka官方下载地址，选择"Binary downloads"，下载对应版本的二进制包（如kafka_2.13-3.6.0.tgz，其中2.13是Scala版本，3.6.0是Kafka版本，无需纠结Scala版本，直接下载即可）；
将下载的压缩包解压到指定目录（建议解压到无中文、无空格的路径，避免出现路径错误，如"D:\Kafka\kafka_2.13-3.6.0"）；
解压完成后，进入Kafka目录，核心目录说明（新手重点关注）：

bin：存放所有可执行命令（如启动Kafka、创建Topic、发送消息的命令）；
config：存放配置文件（核心配置文件为kafka.properties，用于配置Kafka启动参数）；
logs：存放Kafka运行日志（启动失败时，可查看日志排查问题）。

步骤2：修改核心配置文件（关键步骤）

进入Kafka目录下的config文件夹，找到"kafka.properties"文件，用记事本或Notepad++打开，修改以下3个核心配置（其他配置默认即可，新手无需修改）：

配置Kafka监听地址（listeners）：

找到"listeners=PLAINTEXT://:9092"，修改为"listeners=PLAINTEXT://localhost:9092"（指定监听本地地址，避免外部访问，适合单机部署）；

配置Kafka日志存储路径（log.dirs）：

找到"log.dirs=/tmp/kafka-logs"，修改为Kafka目录下的logs文件夹路径（如"log.dirs=D:\Kafka\kafka_2.13-3.6.0\logs"），避免日志存储在临时目录（重启电脑后日志丢失）；

配置KRaft模式（无ZooKeeper）：

找到"process.roles=broker,controller"（默认注释，去掉注释），确保Kafka同时承担broker和controller角色（单机部署无需额外部署controller）；

补充：如果下载的Kafka版本低于2.8.0，没有KRaft相关配置，需额外部署ZooKeeper，本文不讲解该场景，建议新手直接下载2.8.0及以上版本。

步骤3：初始化KRaft元数据（无ZooKeeper模式必备）

打开Windows命令行（cmd），切换到Kafka的bin目录（如"cd D:\Kafka\kafka_2.13-3.6.0\bin"）；
输入初始化命令，生成KRaft元数据：

kafka-storage.bat format --cluster-id abc123 --config .../config/kafka.properties

说明：--cluster-id 后面可以自定义集群ID（如abc123，任意字符串即可），--config 指定配置文件路径（.../config/kafka.properties 表示上级目录的config文件夹下的kafka.properties）；

执行成功后，会提示"Formatting complete"，表示KRaft元数据初始化完成，此时logs目录下会生成相关元数据文件。

步骤4：启动Kafka服务

保持命令行在Kafka的bin目录下，输入启动命令：

kafka-server-start.bat .../config/kafka.properties

启动成功后，命令行会持续输出日志，且不会退出（退出命令行则Kafka服务停止）；
验证启动是否成功：打开新的命令行，输入"netstat -ano | findstr 9092"，若能看到9092端口被占用（Kafka默认端口），说明Kafka启动成功。

步骤5：停止Kafka服务（可选）

如果需要停止Kafka服务，直接关闭启动Kafka的命令行窗口，或在新的命令行（bin目录下）输入停止命令：

kafka-server-stop.bat

Windows部署常见坑点（新手必看）

路径错误：解压路径包含中文、空格，导致启动失败，解决方案：重新解压到无中文、无空格的路径；
JDK环境变量未配置：启动时提示"java不是内部或外部命令"，解决方案：重新配置JAVA_HOME环境变量，重启命令行；
9092端口被占用：启动时提示"Address already in use"，解决方案：关闭占用9092端口的程序（如其他Kafka实例、其他服务），或修改kafka.properties中的监听端口。

三、Kafka单机版部署（Linux环境，生产环境常用）

Linux环境是生产环境中Kafka的常用部署环境，步骤与Windows类似，但命令略有不同，以下以CentOS 7为例，讲解部署步骤（其他Linux发行版如Ubuntu，命令基本一致）。

步骤1：安装JDK并配置环境变量

安装JDK（以JDK 1.8为例）：

yum install java-1.8.0-openjdk-devel -y
配置环境变量：

编辑/etc/profile文件，输入"vi /etc/profile"，在文件末尾添加以下内容：

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk

export PATH= J A V A H O M E / b i n : JAVA_HOME/bin: JAVAHOME/bin:PATH

生效环境变量：

source /etc/profile

验证JDK：输入"java -version"，显示版本信息即配置成功。

步骤2：下载并解压Kafka安装包

进入/usr/local目录（常用软件安装目录）：

cd /usr/local

下载Kafka二进制包（使用wget命令，若未安装wget，先执行"yum install wget -y"）：

wget https://dlcdn.apache.org/kafka/3.6.0/kafka_2.13-3.6.0.tgz

解压压缩包：

tar -zxvf kafka_2.13-3.6.0.tgz

重命名文件夹（可选，方便后续操作）：

mv kafka_2.13-3.6.0 kafka

步骤3：修改核心配置文件

进入Kafka的config目录，编辑kafka.properties文件：

vi /usr/local/kafka/config/kafka.properties

修改以下3个核心配置（与Windows环境一致，仅路径不同）：

listeners=PLAINTEXT://localhost:9092（监听本地地址）；
log.dirs=/usr/local/kafka/logs（日志存储路径，需确保该目录存在，若不存在，执行"mkdir /usr/local/kafka/logs"）；
去掉"process.roles=broker,controller"的注释，启用KRaft模式。

步骤4：初始化KRaft元数据

cd /usr/local/kafka/bin

执行初始化命令：

./kafka-storage.sh format --cluster-id abc123 --config .../config/kafka.properties

执行成功后，提示"Formatting complete"即可。

步骤5：启动Kafka服务（后台启动）

在bin目录下，执行后台启动命令（避免关闭终端后Kafka停止）：

nohup ./kafka-server-start.sh .../config/kafka.properties

验证启动是否成功：

方式1：查看进程，输入"ps -ef | grep kafka"，若能看到kafka相关进程，说明启动成功；

方式2：查看端口，输入"netstat -an | grep 9092"，若9092端口被占用，说明启动成功。

步骤6：停止Kafka服务（可选）

查看Kafka进程ID：

ps -ef | grep kafka

杀死进程（替换为实际的进程ID）：

kill -9 进程ID

Linux部署常见坑点（新手必看）

权限不足：执行命令时提示"Permission denied"，解决方案：在命令前加sudo（如sudo ./kafka-server-start.sh），或修改Kafka目录权限（chmod -R 777 /usr/local/kafka）；
防火墙拦截：外部无法访问9092端口，解决方案：开放9092端口（firewall-cmd --add-port=9092/tcp --permanent，然后执行firewall-cmd --reload）；
日志目录不存在：启动时提示"log directory not found"，解决方案：手动创建logs目录（mkdir /usr/local/kafka/logs）。

四、实操：简单消息收发（命令行方式，新手首选）

Kafka启动成功后，我们通过命令行方式，实现"创建Topic → 生产者发送消息 → 消费者接收消息"的完整流程，直观感受Kafka的消息传递过程，步骤简单，无需编写代码。

说明：Windows和Linux命令行操作基本一致，仅脚本后缀不同（Windows为.bat，Linux为.sh），以下统一讲解，差异处会特别标注。

步骤1：创建Topic（消息分类容器）

打开命令行（Windows cmd / Linux终端），切换到Kafka的bin目录；
输入创建Topic的命令：

bash 复制代码

Windows：kafka-topics.bat --create --topic test_topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1
Linux：./kafka-topics.sh --create --topic test_topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

命令说明（新手必懂）：

- --create：表示创建Topic；

- --topic test_topic：指定Topic名称为test_topic（可自定义，如order_topic）；

- --bootstrap-server localhost:9092：指定Kafka服务地址（单机部署，即本地地址+默认端口）；

- --partitions 1：指定Topic的分区数量为1（新手先从1个分区开始，后续可增加）；

- --replication-factor 1：指定每个分区的副本数量为1（单机部署，无需备份，生产环境建议设为2-3）。

执行成功后，会提示"Created topic test_topic"，表示Topic创建成功。

步骤2：启动生产者（发送消息）

保持命令行在bin目录下，输入启动生产者的命令：

Windows：kafka-console-producer.bat --broker-list localhost:9092 --topic test_topic

Linux：./kafka-console-producer.sh --broker-list localhost:9092 --topic test_topic

启动成功后，命令行会显示">"提示符，此时可以输入消息，每输入一条消息，按回车即可发送到Kafka；
示例：输入"Hello Kafka!""Kafka实操入门""新手学习Kafka"，每条输入后按回车，这些消息会被发送到test_topic中。

步骤3：启动消费者（接收消息）

打开一个新的命令行（不要关闭生产者的命令行），切换到Kafka的bin目录；
输入启动消费者的命令：

Windows：kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic test_topic --from-beginning

Linux：./kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test_topic --from-beginning

命令说明：

--from-beginning：表示从Topic的起始位置开始消费消息（即消费所有已发送的消息），如果不添加该参数，消费者只会消费启动后发送的消息；

启动成功后，消费者命令行会立即显示生产者发送的所有消息，后续生产者发送的消息，消费者会实时接收，实现消息的实时传递。

步骤4：停止生产者和消费者

生产者：直接关闭生产者的命令行窗口，或按"Ctrl+C"停止；
消费者：同样按"Ctrl+C"停止，或关闭命令行窗口。

五、进阶实操：Java代码实现消息收发（可选）

除了命令行方式，实际开发中，我们通常通过代码（如Java、Python）实现Kafka消息的收发。以下提供简单的Java代码示例，基于Kafka官方客户端，步骤清晰，新手可跟着编写，感受实际开发中的消息收发流程。

前置准备：导入Kafka依赖（Maven）

创建一个Java Maven项目，在pom.xml中添加Kafka客户端依赖（版本与部署的Kafka版本一致，如3.6.0）：

bash 复制代码

<dependency>
    <groupId>org.apache.kafka</groupId>

    <artifactId>kafka-clients</artifactId>

    <version>3.6.0</version>

</dependency>

1. Java生产者代码（发送消息）

创建ProducerDemo类，实现消息发送，代码注释详细，新手可直接复制使用：

bash 复制代码

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;

import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;



public class ProducerDemo {

 public static void main(String[] args) {

        // 1. 配置生产者参数

        Properties props = new Properties();

        // Kafka服务地址

        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

        // 消息key的序列化方式（String类型）

        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        // 消息value的序列化方式（String类型）

        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        // 消息确认机制（ACK=1，兼顾效率和可靠性）

        props.put(ProducerConfig.ACKS_CONFIG, "1");



        // 2. 创建Kafka生产者实例

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);



        // 3. 发送消息（发送3条测试消息）

        for (int i = 1; i <= 3; i++) {

            // 创建消息对象（参数：Topic名称、消息key、消息value）

            ProducerRecord<String, String> record = new ProducerRecord<>("test_topic", "key-" + i, "Java发送的消息-" + i);

            // 发送消息（异步发送，无需等待返回）

            producer.send(record, (metadata, exception) -> {

                if (exception == null) {

                    // 发送成功，打印消息发送的位置（Topic、分区、偏移量）

                    System.out.println("消息发送成功：" + metadata.topic() + "-" + metadata.partition() + "-" + metadata.offset());

                } else {

 // 发送失败，打印异常信息

                    exception.printStackTrace();

                }

            });

        }



        // 4. 关闭生产者（释放资源）

        producer.close();

    }

}

2. Java消费者代码（接收消息）

创建ConsumerDemo类，实现消息接收，代码注释详细，可直接复制使用：

bash 复制代码

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;

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 ConsumerDemo {

    public static void main(String[] args) {

        // 1. 配置消费者参数

        Properties props = new Properties();

        // Kafka服务地址

        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

        // 消费者组ID（自定义，如test_group）

        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test_group");

        // 消息key的反序列化方式

        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        // 消息value的反序列化方式

        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        // 自动提交offset（新手首选，简单便捷）

        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");

        // 自动提交offset的时间间隔（1000毫秒）

        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");

        // 从Topic起始位置开始消费消息

        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");



        // 2. 创建Kafka消费者实例

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);



        // 3. 订阅Topic（订阅test_topic）

        consumer.subscribe(Collections.singletonList("test_topic"));



        // 4. 循环消费消息（持续监听消息）

        while (true) {

            // 拉取消息（超时时间为1秒，若没有消息，等待1秒后继续拉取）

            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));

            // 遍历消息并打印

            for (ConsumerRecord<String, String> record : records) {

                System.out.println("收到消息：key=" + record.key() + ", value=" + record.value() + ", 分区=" + record.partition() + ", offset=" + record.offset());

            }

        }

    }

}

代码实操注意事项

确保Kafka服务已启动，否则代码会连接失败；
代码中Kafka服务地址（localhost:9092）需与部署时的配置一致；
先启动消费者代码，再启动生产者代码，否则生产者发送的消息，消费者可能无法接收（若未配置"从起始位置消费"）；
若出现"连接超时""Topic不存在"等异常，检查Kafka服务是否启动、Topic是否创建、端口是否开放。

六、实操总结：新手必掌握的核心要点

通过本文的实操，你已经完成了Kafka环境部署和简单消息收发，总结3个核心要点，帮你巩固实操内容：

部署核心：Kafka依赖JDK，2.8.0及以上版本支持无ZooKeeper模式，部署步骤简化，新手优先选择该版本；
消息流程：创建Topic → 生产者发送消息（指定Topic） → 消费者订阅Topic → 消费者接收消息，这是Kafka消息传递的核心流程；
新手避坑：部署时避免中文路径、配置好JDK环境变量；实操时先启动Kafka服务，再启动生产者和消费者，确保Topic已创建。

七、下一篇预告+互动交流

恭喜你，完成了Kafka系列第四篇的实操学习！通过本文，你已经亲手部署了Kafka环境，实现了消息的发送和接收，真正从"理论"走向了"实操"，迈出了Kafka学习的关键一步。

下一篇文章，我们将深入实操细节------《Kafka实操进阶：Topic/Partition管理 + 消息可靠性配置》。

下一篇我们将讲解如何管理Topic（修改分区数量、删除Topic）、如何配置消息可靠性（ACK机制、副本配置）、如何排查常见的实操故障（消息丢失、消费异常），帮你进一步提升Kafka实操能力，敬请期待！

在部署Kafka或消息收发实操中，你遇到了哪些问题？比如启动失败、消息发送/接收不到，或者代码运行异常？欢迎在评论区留言分享，我们一起交流排查，共同进步！