在安装kafka之前需要先安装zookeeper,因为kafka 启动会将元数据保存在 zookeeper 中,zookeeper是一种分布式协调服务,可以再分布式系统中共享配置,协调锁资源,提供命名服务。
zookeeper 安装
1.在docker中拉取zookeeper 镜像
docker pull wurstmeister/zookeeper
2、运行zookeeper 服务
docker run -d --restart=always --log-driver json-file --log-opt max-size=100m --log-opt max-file=2 --name zookeeper -p 2181:2181 -v /etc/localtime:/etc/localtime wurstmeister/zookeeper
3、查看docker 下是否正常运行zookeeper 服务
docker ps
kafka 安装
1、拉取kafka镜像
docker pull wurstmeister/kafka
2、运行kafka
docker run -d --log-driver json-file --log-opt max-size=100m --log-opt max-file=2 --name kafka -p 9092:9092 -e KAFKA_BROKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=192.168.11.129:2181/kafka -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.11.129:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 -v /etc/localtime:/etc/localtime wurstmeister/kafka
-e KAFKA_BROKER_ID=0 在kafka集群中,每个kafka都有一个BROKER_ID来区分自己
-e KAFKA_ZOOKEEPER_CONNECT=192.168.11.129:2181/kafka 配置zookeeper管理kafka的路径
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.11.129:9092 把kafka的地址端口注册给zookeeper
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 配置kafka的监听端口
-v /etc/localtime:/etc/localtime 容器时间同步虚拟机的时间
注意:这里的192.168.11.129 的ip地址是安装zookeeper和kafka的服务器ip
3、查看kafka是否运行正常
docker ps
4、进入kafka容器
docker exec -it kafka /bin/bash
5、进入kafka的bin目录下:cd /opt/kafka_2.13-2.8.1/bin
6、创建一个新主题(test-kafka)来存储事件
./kafka-topics.sh --create --topic test-kafka --bootstrap-server localhost:9092
显示新主题:test-kafka 的分区信息
./kafka-topics.sh --describe --topic test-kafka --bootstrap-server localhost:9092
测试消费消息:
./kafka-console-consumer.sh --topic test-kafka --from-beginning --bootstrap-server localhost:9092
测试生产消息:
./kafka-console-producer.sh --topic test-kafka --bootstrap-server localhost:9092
=============================↓Java链接kafka↓============================
1.添加maven依赖
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>2.3.1</version>
</dependency>
2.添加配置(bootstrap-servers改为自己服务器的IP地址)
spring:
kafka:
bootstrap-servers: x.x.x.x:9092
producer: # 生产者
retries: 3 # 设置大于0的值,则客户端会将发送失败的记录重新发送
batch-size: 16384
buffer-memory: 33554432
acks: 1
# 指定消息key和消息体的编解码方式
key-serializer: org.apache.kafka.common.serialization.StringSerializer
value-serializer: org.apache.kafka.common.serialization.StringSerializer
consumer:
group-id: default-group
enable-auto-commit: false
auto-offset-reset: earliest
key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
listener:
# 当每一条记录被消费者监听器(ListenerConsumer)处理之后提交
# RECORD
# 当每一批poll()的数据被消费者监听器(ListenerConsumer)处理之后提交
# BATCH
# 当每一批poll()的数据被消费者监听器(ListenerConsumer)处理之后,距离上次提交时间大于TIME时提交
# TIME
# 当每一批poll()的数据被消费者监听器(ListenerConsumer)处理之后,被处理record数量大于等于COUNT时提交
# COUNT
# TIME | COUNT 有一个条件满足时提交
# COUNT_TIME
# 当每一批poll()的数据被消费者监听器(ListenerConsumer)处理之后, 手动调用Acknowledgment.acknowledge()后提交
# MANUAL
# 手动调用Acknowledgment.acknowledge()后立即提交,一般使用这种
# MANUAL_IMMEDIATE
ack-mode: manual_immediate
消费者
package cn.liuhaihua.kafka;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import java.util.Arrays;
import java.util.Properties;
public class CustomerDemo {
public static void main(String[] args) throws InterruptedException {
Properties properties = new Properties();
properties.put("bootstrap.servers", "10.42.139.232:9092");
properties.put("group.id", "group-2");
//session.timeout.ms:消费者在被认为死亡之前可以与服务器断开连接的时间,默认是3s 。
properties.put("session.timeout.ms", "30000");
//消费者是否自动提交偏移量,默认值是true,避免出现重复数据和数据丢失,可以把它设为 false。
properties.put("enable.auto.commit", "false");
properties.put("auto.commit.interval.ms", "1000");
//auto.offset.reset:消费者在读取一个没有偏移量的分区或者偏移量无效的情况下的处理
//earliest:在偏移量无效的情况下,消费者将从起始位置读取分区的记录。
//latest:在偏移量无效的情况下,消费者将从最新位置读取分区的记录
properties.put("auto.offset.reset", "earliest");
properties.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
properties.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
// max.partition.fetch.bytes:服务器从每个分区里返回给消费者的最大字节数
//fetch.max.wait.ms:消费者等待时间,默认是500。
// fetch.min.bytes:消费者从服务器获取记录的最小字节数。
// client.id:该参数可以是任意的字符串,服务器会用它来识别消息的来源。
// max.poll.records:用于控制单次调用 call () 方住能够返回的记录数量
//receive.buffer.bytes和send.buffer.bytes:指定了 TCP socket 接收和发送数据包的缓冲区大小,默认值为-1
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer(properties);
kafkaConsumer.subscribe(Arrays.asList("liuhaihua"));
while (true) {
ConsumerRecords<String, String> records = kafkaConsumer.poll(100);
for (ConsumerRecord<String, String> record : records) {
System.out.printf("offset = %d, value = %s", record.offset(), record.value());
System.out.println("=====================>");
}
}
}
}
生产者
package cn.liuhaihua.kafka;
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 ProducerDemo {
public static void main(String[] args){
Properties properties = new Properties();
//broker的地址清单,建议至少填写两个,避免宕机
properties.put("bootstrap.servers", "10.42.139.232:9092");
//acks指定必须有多少个分区副本接收消息,生产者才认为消息写入成功,用户检测数据丢失的可能性
//acks=0:生产者在成功写入消息之前不会等待任何来自服务器的响应。无法监控数据是否发送成功,但可以以网络能够支持的最大速度发送消息,达到很高的吞吐量。
//acks=1:只要集群的首领节点收到消息,生产者就会收到来自服务器的成功响应。
//acks=all:只有所有参与复制的节点全部收到消息时,生产者才会收到来自服务器的成功响应。这种模式是最安全的,
properties.put("acks", "all");
//retries:生产者从服务器收到的错误有可能是临时性的错误的次数
properties.put("retries", 0);
//batch.size:该参数指定了一个批次可以使用的内存大小,按照字节数计算(而不是消息个数)。
properties.put("batch.size", 16384);
//linger.ms:该参数指定了生产者在发送批次之前等待更多消息加入批次的时间,增加延迟,提高吞吐量
properties.put("linger.ms", 1);
//buffer.memory该参数用来设置生产者内存缓冲区的大小,生产者用它缓冲要发送到服务器的消息。
properties.put("buffer.memory", 33554432);
//compression.type:数据压缩格式,有snappy、gzip和lz4,snappy算法比较均衡,gzip会消耗更高的cpu,但压缩比更高
//key和value的序列化
properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
//client.id:该参数可以是任意的字符串,服务器会用它来识别消息的来源。
//max.in.flight.requests.per.connection:生产者在收到服务器晌应之前可以发送多少个消息。越大越占用内存,但会提高吞吐量
//timeout.ms:指定了broker等待同步副本返回消息确认的时间
//request.timeout.ms:生产者在发送数据后等待服务器返回响应的时间
//metadata.fetch.timeout.ms:生产者在获取元数据(比如目标分区的首领是谁)时等待服务器返回响应的时间。
// max.block.ms:该参数指定了在调用 send()方法或使用 partitionsFor()方法获取元数据时生产者阻塞时间
// max.request.size:该参数用于控制生产者发送的请求大小。
//receive.buffer.bytes和send.buffer.bytes:指定了 TCP socket 接收和发送数据包的缓冲区大小,默认值为-1
Producer<String, String> producer = null;
try {
producer = new KafkaProducer(properties);
for (int i = 0; i < 1000; i++) {
String msg = "1.74.103."+i+"\t"
+"2018-12-20 18:12:00"+"\t"+"\"GET /class/130.html HTTP/1.1\""+"\t"+"404"+"\t"+"https://search.yahoo.com/search?p=Flink实战";
producer.send(new ProducerRecord<String, String>("liuhaihua", msg));
Thread.sleep(500);
System.out.println("Sent:" + msg);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
producer.close();
}
}
}