Kafka集群搭建详细步骤

Kafka集群搭建

1、 Kafka的安装需要java环境，cent os 7自带java1.6版本，可以不用重新安装，直接使用自带的jdk 即可；如果觉得jdk版本太旧，也可以自己重新安装；

2、 准备好kafka安装包，官网下载地址：
http://kafka.apache.org/downloads.html

3、 下载好kafka安装包后，将其解压到/usr/local目录下，删除压缩包

4、 目前搭建了三个节点的kafka集群，分别在10.10.67.102，10.10.67.104和10.10.67.106服务器上；

5、 查看配置文件
进入kafka的config的目录：

6、 先建立zk集群，直接使用kafka自带的zookeeper建立zk集群，修改zookeeper.properties文件：

三个机器上的zookeeper.properties文件配置相同，需要注意的是日志保存的路径，不会自动生成，需要自己手动建立相关的路径， dataLogDir是我自己加的，日志文件太多，把日志文件区分开；

7、 创建myid文件，进入/usr/local/kafka/zookeeper，创建myid文件，将三个服务器上的myid文件分别写入1，2，3，如图：

—-myid是zk集群用来发现彼此的标识，必须创建，且不能相同；

8、 进入kafka目录 执行启动zookeeper命令：
./bin/zookeeper-server-start.sh config/zookeeper.properties &
三台机器都执行启动命令，查看zookeeper的日志文件，没有报错就说明zookeeper集群启动成功了。

9、 搭建kafka集群，修改server.properties配置文件：

server.properties配置文件的修改主要在开头和结尾，中间保持默认配置即可；需要注意的点是broker.id的值三个节点要配置不同的值，分别配置为0，1，2；log.dirs必须保证目录存在，不会根据配置文件自动生成；

10、 启动kafka集群，进入kafka目录，执行如下命令 ：
./bin/kafka-server-start.sh –daemon config/server.properties &
三个节点均要启动；启动无报错，即搭建成功，可以生产和消费消息，来检测是否搭建成功。

11、java客户端生产与消费测试

本人直接使用的lib包的方式进行测试的，并非maven。如下是本人的lib包

这些lib包都是可以再kafka根目录下的libs里面找到的。
1.首先利用kafka api创建一个生产者：

package com.KafkaService;

import java.util.Properties;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class KafkaProducerService {
    private static Logger LOG = LoggerFactory
            .getLogger(KafkaProducerService.class);

    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "192.168.1.1:9092,192.168.1.2:9092,192.168.1.3:9092");
        props.put("retries", 3);
        props.put("linger.ms", 1);
        props.put("key.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer producer = new KafkaProducer(
                props);
        for (int i = 0; i < 1; i++) {
            ProducerRecord record = new ProducerRecord(
                    "tests", "11", "今天天气不错哟yoyo=======>" + i);
            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception e) {
                    // TODO Auto-generated method stub
                    if (e != null)
                        System.out.println("the producer has a error:"
                                + e.getMessage());
                    else {
                        System.out
                                .println("The offset of the record we just sent is: "
                                        + metadata.offset());
                        System.out
                                .println("The partition of the record we just sent is: "
                                        + metadata.partition());
                    }
                }
            });
            try {
                Thread.sleep(1000);
                // producer.close();
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        }
    }
}

其次，创建消费者代码：

package com;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Joker
 * 自己控制偏移量提交
 * 很多时候，我们是希望在获得消息并经过一些逻辑处理后，才认为该消息已被消费，这可以通过自己控制偏移量提交来实现。
 */
public class ManualOffsetConsumer {
    private static Logger LOG = LoggerFactory.getLogger(ManualOffsetConsumer.class);

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Properties props = new Properties();
        //设置brokerServer(kafka)ip地址
        props.put("bootstrap.servers", "192.168.1.1:9092,192.168.1.2:9092,192.168.1.3:9092");
        //设置consumer group name
        props.put("group.id","mygroup11");
        props.put("enable.auto.commit", "false");
        //设置使用最开始的offset偏移量为该group.id的最早。如果不设置，则会是latest即该topic最新一个消息的offset
        //如果采用latest，消费者只能得道其启动后，生产者生产的消息
        props.put("auto.offset.reset", "earliest");
      //设置心跳时间
        props.put("session.timeout.ms", "30000");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer consumer = new KafkaConsumer(props);
        consumer.subscribe(Arrays.asList("test"));
        final int minBatchSize = 5;  //批量提交数量
         List> buffer = new ArrayList<>();
         while (true) {
             ConsumerRecords records = consumer.poll(100);
             for (ConsumerRecord record : records) {
                 System.out.println("consumer message values is "+record.value()+" and the offset is "+ record.offset());
                 buffer.add(record);
             }
             if (buffer.size() >= minBatchSize) {
                 System.out.println("now commit offset"+buffer.size());
                 consumer.commitSync();
                 buffer.clear();
             }
         }
    }
}

如此便是java客户端的一个生产者以及消费者的例子，例子中消费者只是利用了一个简单的main方面进行测试，在正常使用中必然要使用线程去监听消费队列的，而在生产这方面也是要利用线程去提交数据，保障主线程的畅通等等，这点根据自己的业务需要进行完善了，本人这里也只是抛砖引玉罢了。最后，本文都是基于本人实际搭建过程的心得，若有错误欢迎指正。