kafka的搭建与使用

安装

一、安装jdk

创建java安装目录

[root@This-Address-Is-Forged-64 opt]# mkdir /opt/java
[root@This-Address-Is-Forged-64 opt]# ll
total 0
drwxr-xr-x. 3 root root  60 Feb 26 20:18 java

并将下载的jdk-8u181-linux-x64.tar.gz放到/opt/java下面，并解压。

[root@This-Address-Is-Forged-64 java]# tar -zxvf jdk-8u181-linux-x64.tar.gz
[root@This-Address-Is-Forged-64 java]# ll
total 181296
drwxr-xr-x. 7   10  143       245 Jul  7  2018 jdk1.8.0_181
-rw-r--r--. 1 root root 185646832 Feb 26 19:53 jdk-8u181-linux-x64.tar.gz

编辑环境变量

[root@This-Address-Is-Forged-64 java]# vi /etc/profile
export JAVA_HOME=/opt/java/jdk1.8.0_181
export JRE_HOME=$JAVA_HOME/jre
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=./:JAVA_HOME/lib:$JRE_HOME/lib

保存退出后，使环境变量生效。

[root@This-Address-Is-Forged-64 java]# source /etc/profile

验证java安装是否成功

[root@This-Address-Is-Forged-64 java]# java -version
java version "1.8.0_181"
Java(TM) SE Runtime Environment (build 1.8.0_181-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)

二、安装zookeeper（单节点安装）

创建zookeeper安装目录

[root@This-Address-Is-Forged-64 opt]# mkdir /opt/zookeeper
[root@This-Address-Is-Forged-64 opt]# ll
total 0
drwxr-xr-x. 5 root root  90 Feb 26 20:32 zookeeper

将下载的zookeeper-3.4.6.tar.gz放到/opt/zookeeper目录下，并解压

[root@This-Address-Is-Forged-64 zookeeper]# tar -zxvf zookeeper-3.4.6.tar.gz
[root@This-Address-Is-Forged-64 zookeeper]# ll
total 181296
drwxr-xr-x. 10 1000 1000     4096 Feb 20  2014 zookeeper-3.4.6
-rw-r--r--.  1 root root 17699306 Feb 26 20:29 zookeeper-3.4.6.tar.gz

创建zookeeper data目录和log目录

[root@This-Address-Is-Forged-64 zookeeper]# mkdir /opt/zookeeper/zkdata
[root@This-Address-Is-Forged-64 zookeeper]# mkdir /opt/zookeeper/zkdatalog
[root@This-Address-Is-Forged-64 zookeeper]# ll
total 17292
drwxr-xr-x.  3 root root       63 Feb 26 20:33 zkdata
drwxr-xr-x.  3 root root       23 Feb 26 20:33 zkdatalog
drwxr-xr-x. 10 1000 1000     4096 Feb 20  2014 zookeeper-3.4.6
-rw-r--r--.  1 root root 17699306 Feb 26 20:29 zookeeper-3.4.6.tar.gz

修改配置文件

[root@This-Address-Is-Forged-64 zookeeper]# cd /opt/zookeeper/zookeeper-3.4.6/conf
[root@This-Address-Is-Forged-64 conf]# cp zoo_sample.cfg zoo.cfg
[root@This-Address-Is-Forged-64 conf]# vi zoo.cfg
dataDir=/opt/zookeeper/zkdata
dataLogDir=/opt/zookeeper/zkdatalog

保存退出，并启动服务：

[root@This-Address-Is-Forged-64 conf]# cd /opt/zookeeper/zookeeper-3.4.6/bin
[root@This-Address-Is-Forged-64 bin]# ./zkServer.sh start  

查看状态

[root@This-Address-Is-Forged-64 bin]# ./zkServer.sh status  
JMX enabled by default
Using config: /opt/zookeeper/zookeeper-3.4.6/bin/../conf/zoo.cfg
Mode: standalone

则安装成功。

三、安装kafka（三节点安装）

创建kafka安装目录

[root@This-Address-Is-Forged-64 opt]# mkdir /opt/kafka
[root@This-Address-Is-Forged-64 opt]# ll
total 0
drwxr-xr-x. 3 root root  60 Feb 26 20:18 kafka

将下载的kafka_2.13-2.4.0.tgz放到此目录下，并解压。

[root@This-Address-Is-Forged-64 opt]# cd /opt/kafka
[root@This-Address-Is-Forged-64 kafka]# tar -zxvf kafka_2.13-2.4.0.tgz
[root@This-Address-Is-Forged-64 kafka]# ll
total 60600
drwxr-xr-x. 7 root root      101 Feb 26 21:19 kafka_2.13-2.4.0
-rw-r--r--. 1 root root 62051390 Feb 26 20:56 kafka_2.13-2.4.0.tgz

分别创建三节点kafka目录

mkdir -p /opt/kafka/kafka1      ##第一个节点目录
mkdir -p /opt/kafka/kafka1/logs   ## 第一个节点日志目录
mkdir -p /opt/kafka/kafka1/config    ##第一个节点配置文件目录
mkdir -p /opt/kafka/kafka2      ##第二个节点目录
mkdir -p /opt/kafka/kafka2/logs  ## 第二个节点日志目录
mkdir -p /opt/kafka/kafka2/config    ##第二个节点配置文件目录 
mkdir -p /opt/kafka/kafka3      ##第三个节点目录
mkdir -p /opt/kafka/kafka3/logs  ## 第三个节点日志目录
mkdir -p /opt/kafka/kafka3/config    ##第三个节点配置文件目录

将配置文件放入对应的config目录下

cp kafka_2.13-2.4.0/config/server.properties kafka1/config
cp kafka_2.13-2.4.0/config/server.properties kafka2/config
cp kafka_2.13-2.4.0/config/server.properties kafka3/config

分别修改对应的server.properties文件
vim server.properties

broker.id=1  ##设置kafka broker的id，本次分别为1,2,3；
listeners=PLAINTEXT://yourIP:9091  ##设置kafka的监听地址和端口号，本次分别设置为9091,9092,9093;
log.dirs=/opt/kafka/kafka1/logs  ##设置kafka日志数据存储路径；
zookeeper.connect=yourIP:2181

启动：

kafka_2.13-2.4.0/bin/kafka-server-start.sh -daemon kafka1/config/server.properties
kafka_2.13-2.4.0/bin/kafka-server-start.sh -daemon kafka2/config/server.properties
kafka_2.13-2.4.0/bin/kafka-server-start.sh -daemon kafka3/config/server.properties

使用（java代码示例）

1.创建maven工程，并引入kafka-clients包。

 <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>2.4.0</version>
    </dependency>

2.producer代码

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

import java.util.Properties;

public class ProducerTest {
  public static void main(String[] args) {
      Properties props = new Properties();
      props.put("bootstrap.servers", "yourIp:port");

      props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
      props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

      Producer<String, String> producer = new KafkaProducer<>(props);
      for (int i = 0; i < 100; i++)
          producer.send(new ProducerRecord<String, String>("my-topic1", Integer.toString(i), Integer.toString(i)));

      producer.close();
  }
}

要往 Kafka 写入消息，首先要创建一个生产者对象，并设置一些属性。Kafka 生产者有 3
个必选的属性。
bootstrap.servers
该属性指定 broker 的地址清单，地址的格式为 host:port。清单里不需要包含所有的
broker 地址，生产者会从给定的 broker 里查找到其他 broker 的信息。不过建议至少要
提供两个 broker 的信息，一旦其中一个宕机，生产者仍然能够连接到集群上。
key.serializer
broker 希望接收到的消息的键和值都是字节数组。生产者接口允许使用参数化类型，因
此可以把 Java 对象作为键和值发送给 broker。这样的代码具有良好的可读性，不过生
产者需要知道如何把这些 Java 对象转换成字节数组。key.serializer 必须被设置为一
个实现了 org.apache.kafka.common.serialization.Serializer 接口的类，生产者会使
用这个类把键对象序列化成字节数组。Kafka 客户端默认提供了 ByteArraySerializer
（这个只做很少的事情）、StringSerializer 和 IntegerSerializer，因此，如果你只
使用常见的几种 Java 对象类型，那么就没必要实现自己的序列化器。要注意，key.
serializer 是必须设置的，就算你打算只发送值内容。
value.serializer
与 key.serializer 一样，value.serializer 指定的类会将值序列化。如果键和值都是字
符串，可以使用与 key.serializer 一样的序列化器。如果键是整数类型而值是字符串，
那么需要使用不同的序列化器。

将参数传入producer，即可像topic发送数据，示例是像my-topic1发送key和value都是1-99的数字。
3.consumer代码

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.Arrays;
import java.util.Properties;

public class ConsumerTest {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "yourIp:port");
        props.setProperty("group.id", "test1");
        props.setProperty("enable.auto.commit", "true");
        props.setProperty("auto.offset.reset", "earliest");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("my-topic1"));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records)
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        }
    }
}

在读取消息之前，需要先创建一个 KafkaConsumer 对象。创建 KafkaConsumer 对象与创建
KafkaProducer 对象非常相似——把想要传给消费者的属性放在 Properties 对象里。

创建好消费者之后，下一步可以开始订阅主题了。subscribe() 方法接受一个主题列表作
为参数。
消息轮询是消费者 API 的核心，通过一个简单的轮询向服务器请求数据。一旦消费者订阅
了主题，轮询就会处理所有的细节，包括群组协调、分区再均衡、发送心跳和获取数据，
开发者只需要使用一组简单的 API 来处理从分区返回的数据。

详细配置

1.生产者配置

1. acks
   acks=0，生产者在成功写入消息之前不会等待任何来自服务器的响应。
   acks=1，只要集群的首领节点收到消息，生产者就会收到一个来自服务器的成功响应。
   acks=all，只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。因为我们要等待不只一个服务器节点接收消息。
2. buffer.memory
   该参数用来设置生产者内存缓冲区的大小。
3. compression.type
   默认情况下，消息发送时不会被压缩。该参数可以设置为 snappy、gzip 或 lz4。
4. retries
   retries 参数的值决定了生产者可以重发消息的次数。
5. batch.size
   该参数指定了一个批次可以使用的内存大小，按照字节数计算（而不是消息个数）。
6. linger.ms
   KafkaProducer 会在批次填满或 linger.ms 达到上限时把批次发送出去。
7. client.id
   该参数可以是任意的字符串，服务器会用它来识别消息的来源，还可以用在日志和配额指标里。
8. max.in.flight.requests.per.connection
   该参数指定了生产者在收到服务器响应之前可以发送多少个消息。
9. timeout.ms、request.timeout.ms 和 metadata.fetch.timeout.ms
   request.timeout.ms 指定了生产者在发送数据时等待服务器返回响应的时间，metadata.
   fetch.timeout.ms 指定了生产者在获取元数据（比如目标分区的首领是谁）时等待服务器
   返回响应的时间。
   timeout.ms 指定了 broker 等待同步副本返回消息确认的时间
10. max.block.ms
    该参数指定了在调用 send() 方法或使用 partitionsFor() 方法获取元数据时生产者的阻塞
    时间。
11. max.request.size
    该参数用于控制生产者发送的请求大小。
12. receive.buffer.bytes 和 send.buffer.bytes
    这两个参数分别指定了 TCP socket 接收和发送数据包的缓冲区大小。如果它们被设为 -1，
    就使用操作系统的默认值。

2.消费者配置

1. fetch.min.bytes
   该属性指定了消费者从服务器获取记录的最小字节数。
2. fetch.max.wait.ms
   指定 broker 的等待时间，默认是 500ms。
3. max.partition.fetch.bytes
   该属性指定了服务器从每个分区里返回给消费者的最大字节数。它的默认值是 1MB。
4. session.timeout.ms
   该属性指定了消费者在被认为死亡之前可以与服务器断开连接的时间，默认是 3s。
5. auto.offset.reset
   它的默认值是 latest，意思是说，在偏移量无效的情况下，消费者将从最新的记录开始读取数据（在消费者启动之
   后生成的记录）。另一个值是 earliest，意思是说，在偏移量无效的情况下，消费者将从起始位置读取分区的记录。
6. enable.auto.commit
   该属性指定了消费者是否自动提交偏移量，默认值是 true。
7. partition.assignment.strategy
   决定哪些分区应该被分配给哪个消费者。Kafka 有两个默认的分配策略。
   Range
   该策略会把主题的若干个连续的分区分配给消费者。
   RoundRobin
   该策略把主题的所有分区逐个分配给消费者。
8. client.id
   该属性可以是任意字符串，broker 用它来标识从客户端发送过来的消息，通常被用在日志、
   度量指标和配额里。
9. max.poll.records
   该属性用于控制单次调用 call() 方法能够返回的记录数量。

来源：CSDN

作者：directshowplayer

链接：https://blog.csdn.net/directshowplayer/article/details/104799946