Kafka 学习

最新推荐文章于 2023-12-19 15:29:10 发布

bw_ustc

最新推荐文章于 2023-12-19 15:29:10 发布

阅读量327

点赞数 1

本文链接：https://blog.csdn.net/bw_ustc/article/details/104115889

版权

20.1.30 Kafka 学习

第 1 章 Kafka 概述
第 2 章 Kafka 快速入门
第 3 章 Kafka 架构深入
第 4 章 Kafka API
第 5 章 Kafka 监控
第 6 章 Flume 对接 Kafka
第 7 章 Kafka 面试题

第 1 章 Kafka 概述

1.1 定义

在这里插入图片描述
只要使用spark，那么百分之90的数据来源于kafka,其对于实时性的很重要。

1.2 消息队列

1.2.1 传统消息队列的应用场景

在这里插入图片描述

解耦，两端不需要同时在线。
削峰。解决生产消息速度远远大于消费消息速度的问题。

灵活性：可以随时上下线。

1.2.2 消息队列的两种模式

在这里插入图片描述
缺点：消息不可复用。

发布订阅模式里也分两种模式，一种是消费者主动拉消息，可以自己控制获取消息的速度，kafka就是这样（也有缺点，有点耗资源），还有一种是生产者主动推消息。（缺点，如果主动推，有的消费者处理消息速度慢，可能会崩）
在这里插入图片描述

1.3 Kafka 基础架构

在这里插入图片描述

比如点赞的消息就是一个topic 浏览的消息也是一个topic 他们属于不同的topic，传进来的消息要分类！
一个topic有多个partition ，这样可以提高kafka负载均衡的能力，同时提高并发度。

消费者组订阅的是topic，同一个分区的数据不可以被同一个消费者组里的不同消费者使用，但是可以被不同消费者组的不同消费者使用。

消费者组里消费者的数量要小于等于某个topic的分区数，大于的话，，假设topicA有两个分区，消费组A订阅它，里面有三个消费者，前两个消费者订阅不同分区的数据，第三个消费者啥事也没有，浪费资源。
在这里插入图片描述

leader是针对某个分区的，而不是针对某个broken，follower起到备份的作用，确保kafka高可靠、高可用，所以leader和follower一定不在同一台机器上。而消费者和生产者一定找的是leader，follower仅仅起到备份的作用

第 2 章 Kafka 快速入门

2.1 安装部署

2.1.1 集群规划

在这里插入图片描述

2.1.2 jar 包下载

在这里插入图片描述

2.1.3 集群部署

1）解压安装包

[BW@hadoop102 software]$ tar -zxvf kafka_2.11-0.11.0.0.tgz -C /opt/module/
[BW@hadoop102 module]$ mv kafka_2.11-0.11.0.0/ kafka

在这里插入图片描述
2）修改解压后的文件名称

[atguigu@hadoop102 module]$ mv kafka_2.11-0.11.0.0/ kafka

3）在/opt/module/kafka 目录下创建 logs 文件夹

[atguigu@hadoop102 kafka]$ mkdir logs

4）修改配置文件

[atguigu@hadoop102 kafka]$ cd config/
[atguigu@hadoop102 config]$ vi server.properties

在这里插入图片描述

在这里插入图片描述
5）配置环境变量

[atguigu@hadoop102 module]$ sudo vi /etc/profile
#KAFKA_HOME
export KAFKA_HOME=/opt/module/kafka
export PATH=$PATH:$KAFKA_HOME/bin

[atguigu@hadoop102 module]$ source /etc/profile

6）分发安装包

[atguigu@hadoop102 module]$ xsync kafka/

在这里插入图片描述
分发成功：

改103 104：

104改成2

8）启动集群
启动集群之前一定要把zookeeper集群启动！
分别启动Zookeeper

[atguigu@hadoop102 zookeeper-3.4.10]$ bin/zkServer.sh start
[atguigu@hadoop103 zookeeper-3.4.10]$ bin/zkServer.sh start
[atguigu@hadoop104 zookeeper-3.4.10]$ bin/zkServer.sh start

然后依次在 hadoop102、 hadoop103、 hadoop104 节点上启动 kafka

[BW@hadoop102 kafka]$ bin/kafka-server-start.sh config/server.properties

启动成功发现是阻塞进程
在这里插入图片描述
以守护进程的方式启动

[atguigu@hadoop102 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties
[atguigu@hadoop103 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties
[atguigu@hadoop104 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties

在这里插入图片描述
9）关闭集群

 [atguigu@hadoop102 kafka]$ bin/kafka-server-stop.sh stop
[atguigu@hadoop103 kafka]$ bin/kafka-server-stop.sh stop
[atguigu@hadoop104 kafka]$ bin/kafka-server-stop.sh stop

10） kafka 群起脚本

[BW@hadoop102 bin]$ vim kk.sh

添加以下内容：

#!/bin/bash

case $1 in
"start"){

	for i in hadoop102 hadoop103 hadoop104
	do
		echo "========== $i =========="
		ssh $i "/opt/module/kafka/bin/kafka-server-start.sh -daemon /opt/module/kafka/config/server.properties"
	done
};;

"stop"){

        for i in hadoop102 hadoop103 hadoop104
        do
                echo "========== $i =========="
                ssh $i "/opt/module/kafka/bin/kafka-server-stop.sh"
        done
};;
esac

修改权限

[BW@hadoop102 bin]$ chmod 777 kk.sh

群起：(不成功！)

[BW@hadoop102 bin]$ kk.sh start

群停成功！奇怪了！！！

[BW@hadoop102 bin]$ kk.sh stop

在这里插入图片描述

2.2 Kafka 命令行操作

1）查看当前服务器中的所有 topic

[atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --zookeeper hadoop102:2181 --list

无反应
在这里插入图片描述

2）创建 topic 来分类数据

[atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --zookeeper hadoop102:2181 --create --replication-factor 2 --partitions 2 --topic first

依赖于zk存储数据
在这里插入图片描述

一共两个first0 两个first1 由于是两个副本，0 和1 是分区号，说明数据是存在磁盘的 是按照主题加分区名来命名的

要求副本数不能超过分区数
3）删除 topic

[atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --zookeeper hadoop102:2181 --delete --topic first

在这里插入图片描述
4）发送消息

开启生产者：

[atguigu@hadoop102 kafka]$ bin/kafka-console-producer.sh --broker-list hadoop102:9092 --topic first
>hello world
>atguigu atguigu

在这里插入图片描述
5）消费消息

在103 和104 开启消费者：

[atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh --zookeeper hadoop102:2181 --topic first
[atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
[atguigu@hadoop104 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --from-beginning --topic first

在这里插入图片描述

6）查看某个 Topic 的详情

[atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --zookeeper hadoop102:2181 --describe --topic first

在这里插入图片描述
7）修改分区数

[atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --zookeeper hadoop102:2181 --alter --topic first --partitions 6

然后进行数据和日志分离：
在102 103 104 都输入：

[BW@hadoop102 kafka]$ rm -rf logs/

然后进入zookeeper,里面存了很多kafka的元数据：
除了zookeeper，其他都是kafka的
在这里插入图片描述
用rmr 命令删除。
然后分别进入102 103 104的配置文件修改到data目录

[BW@hadoop104 kafka]$ cd /opt/module/kafka/config/
[BW@hadoop104 config]$ vim server.properties

在这里插入图片描述

第 3 章 Kafka 架构深入

3.1 Kafka 工作流程及文件存储机制

在这里插入图片描述

kafka只能保证区内有序性，不能保证全局有序性。每一个分区都维护了一个偏移量。

分片指的就是一片最大是1G。
下面这个偏移量是index文件下面的log文件的最小的偏移量

也就是说在first-0文件夹下分多个segment，上图有三个segment，分别是000 410 430，每个segment对应一个index文件和一个log文件。
log文件存放实际的数据。是经过序列化的
在这里插入图片描述
0 237 562 756 912 1016 是对应log文件6条消息的起始偏移量

3.2 Kafka 生产者

3.2.1 分区策略

在这里插入图片描述

3.2.2 数据可靠性保证

在这里插入图片描述

在这里插入图片描述
由于生产者没有收到ack 所以会重新发数据，但是之前已经同步好了所以会造成数据重复。

（1）保证的是消费的一致性，（2）保证的是存储数据的一致性。

3.2.3 Exactly Once 语义

在这里插入图片描述

3.3 Kafka 消费者

3.3.1 消费方式

在这里插入图片描述

3.3.2 分区分配策略

在这里插入图片描述

这种策略是按照消费者组来分的
会将消费者组订阅的所有的topic的所有分区放在一起，取每个分区的hash值然后进行排序，然后整体进行轮询。
好处：每个消费者最多差一个分区的数据
存在的问题：使用的前提条件是一个消费者组里的几个消费者订阅的主题是一致的，如果消费者1订阅topic1 消费者2订阅topic2 那么使用轮询的方法，topic1的数据会传到消费者2里不符合业务逻辑。
在这里插入图片描述
系统默认的是这个策略。是按照主题分的，

存在的问题：

A有4个 B有2个，存在消费者消费消息不对等的情况。

当消费者数量增加或者减少时，都会触发重新分配（重新触发分区分配策略）。

3.3.3 offset 的维护（保存在zookeeper里）

在这里插入图片描述
唯一确定offset ：消费者组、主题、分区。
假设消费者1消费topic1里的三个分区，消费到10条数据了，这时候进来了消费者2，所以分区分配策略触发，消费者2 至少消费1个分区，他是接着消费，不是从头开始消费
在这里插入图片描述

1）修改配置文件 consumer.properties

exclude.internal.topics=false

2）读取 offset

0.11.0.0 之前版本:

bin/kafka-console-consumer.sh --topic __consumer_offsets --zookeeper hadoop102:2181 --formatter
"kafka.coordinator.GroupMetadataManager\$OffsetsMessageFormatter" --consumer.config config/consumer.properties --from-beginning

0.11.0.0 之后版本(含):

bin/kafka-console-consumer.sh --topic __consumer_offsets --zookeeper hadoop102:2181 --formatter
"kafka.coordinator.group.GroupMetadataManager\$OffsetsMessageFormatter" --consumer.config config/consumer.properties --frombeginning

元数据是保存在zookeeper里：
在这里插入图片描述

消费者组的id

而且也保存在本地：

在本地也是按照消费者组-topic-分区来唯一确定offset

在文件是按照KV键值对保存的 k就是消费者组-topic-分区的哈希值，v就是offset。

这里不是消费者而是消费者组如果是消费者当该消费者挂了以后，就找不到k 如果是消费者组，当一个消费者挂了以后消费者组还存在，这样可以给别的消费者继续进行消费
在这里插入图片描述

3.3.4 消费者组案例

在这里插入图片描述

[atguigu@hadoop103 config]$ vi consumer.properties
group.id=atguigu

在这里插入图片描述

（2）在 hadoop102、 hadoop103 上分别启动消费者

[atguigu@hadoop102 kafka]$ bin/kafka-console-consumer.sh --zookeeper hadoop102:2181 --topic first --consumer.config config/consumer.properties
[atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first --consumer.config config/consumer.properties

（3）在 hadoop104 上启动生产者

[atguigu@hadoop104 kafka]$ bin/kafka-console-producer.sh --broker-list hadoop102:9092 --topic first
>hello world

（4）查看 hadoop102 和 hadoop103 的接收者。

同一时刻只有一个消费者接收到消息。

注意：
不同组只要订阅了该topic，就可以同时消费信息
例如102 104 客户端属于不同组，同时订阅topic bigdata（两个分区），所以102 104 同时接收aaa,但是102（1）和102（2）属于同一组，不能同时消费，轮询消费。
如果再启动一个102(3)和之前的102属于同一个组，会重新触发分区机制，下一次发送的两个消息由102（1）和102（3）消费了。
在这里插入图片描述

这个写谁都行因为他们是以集群方式工作的

3.4 Kafka 高效读写数据

在这里插入图片描述

3.5 Zookeeper 在 Kafka 中的作用

在这里插入图片描述

3.6 Kafka 事务

在这里插入图片描述

3.6.1 Producer 事务

在这里插入图片描述
之前的幂等性是解决单会话单分区的问题，引入Producer 事务结合之前的幂等性可以做到跨会话（Producer 挂了，重连，就不算同一次会话了）跨分区的精准一次性写入。

3.6.2 Consumer 事务

在这里插入图片描述

第 4 章 Kafka API

4.1 Producer API

4.1.1 消息发送流程

在这里插入图片描述
与ack:
假设发送消息123 和456 。分批次发送，发送完123后，继续发456，来了789继续发789，如果发123的ack一直收不到的话，就重发123。 456 789 类似。

4.1.2 异步发送 API

建一个maven工程，导入依赖：

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>0.11.0.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka_2.12</artifactId>
        <version>0.11.0.0</version>
    </dependency>
</dependencies>

然后建一个包再建一个类
在这里插入图片描述

package kafka;

import java.util.Properties;

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

public class CustomerProducer {
	public static void main(String[] args) {
		
		//1.创建kafka生产对象的配置信息
		Properties props=new Properties();
		
		//2.添加配置信息
		//指定连接的kafka集群
		props.put("bootstrap.servers", "hadoop102:9092");
		//ack应答级别
		props.put("acks", "all");
		//重试次数
		props.put("retries", 0);
		//批次大小 一次发送多少大小的数据 单位字节 大约16k 每到16k 发送到内存中，内存最大的大小是32M
		props.put("batch.size", 16384);
		//等待时间 默认1毫秒
		props.put("linger.ms", 1);
		//RecordAccumulator 缓冲区大小 32M
		props.put("buffer.memory", 33554432);
		//key value 的序列化对
		props.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
		props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");
		
		//3. 创建生产者对象
		KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
		
		//4.发送数据
		for (int i = 0; i < 10; i++) {
			
			producer.send(new ProducerRecord<String, String>("bw", "BW--"+i));
		}
		
		//5.关闭资源
		producer.close();
	}

}

然后在102 103 104开启zookeeper的服务端

[BW@hadoop103 zookeeper-3.4.10]$ bin/zkServer.sh start

然后开启102 kafka的服务端

[BW@hadoop102 kafka]$ bin/kafka-server-start.sh config/server.properties

然后开启客户端：

[BW@hadoop102 kafka]$ bin/kafka-console-consumer.sh --zookeeper hadoop102:2181 --topic bw

在这里插入图片描述
接收成功

批量发送：

4.2.3 创建生产者带回调函数（新API）

在这里插入图片描述
修改上面的代码：

package kafka;

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;

public class CustomerProducer {
	public static void main(String[] args) {
		
		//1.创建kafka生产对象的配置信息
		Properties props=new Properties();
		
		//2.添加配置信息
		//指定连接的kafka集群
		props.put("bootstrap.servers", "hadoop102:9092");
		//ack应答级别
		props.put("acks", "all");
		//重试次数
		props.put("retries", 0);
		//批次大小 一次发送多少大小的数据 单位字节 大约16k 每到16k 发送到内存中，内存最大的大小是32M
		props.put("batch.size", 16384);
		//等待时间 默认1毫秒
		props.put("linger.ms", 1);
		//RecordAccumulator 缓冲区大小 32M
		props.put("buffer.memory", 33554432);
		//key value 的序列化对
		props.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
		props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");
		
		//3. 创建生产者对象
		KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
		
		//4.发送数据
		for (int i = 0; i < 10; i++) {
			
			//producer.send(new ProducerRecord<String, String>("bw", "BW--"+i));
			producer.send(new ProducerRecord<String, String>("bw", "BW--"+i),new Callback() {
				
				public void onCompletion(RecordMetadata metadata, Exception exception) {
					
					if(exception==null) {
						System.out.println(metadata.partition()+"---"+metadata.offset());
					}else {
						System.out.println("发送失败");
					}
					
				}
			});
		}
		
		//5.关闭资源
		producer.close();
	}

}

运行程序：
在这里插入图片描述
客户端：

之前是一个分区，下面演示多分区：
创建一个主题：

[BW@hadoop102 kafka]$ bin/kafka-topics.sh --zookeeper hadoop102:2181 --create --topic second --partitions 3 --replication-factor 1

将之前的消费者停掉：重新启动 topic改成second

在这里插入图片描述
启动程序：

前面分区后面偏移量每个分区维护自己的偏移量所以都从0开始。

说明是分区发送的，先消费一个分区，这个分区消费完了，再消费下一个分区。

4.2.4 自定义分区生产者

编写CustomerProducer类实现Partitioner接口，重写里面的方法

package kafka;

import java.util.Map;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

public class CustomerPatition implements Partitioner{

	public void configure(Map<String, ?> configs) {
		// TODO Auto-generated method stub
		
	}

	public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
		// 控制分区
		return 0;
	}

	public void close() {
		// TODO Auto-generated method stub
		
	}

}

在代码中调用

package kafka;

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;

public class CustomerProducer {
	public static void main(String[] args) {
		
		//1.创建kafka生产对象的配置信息
		Properties props=new Properties();
		
		//2.添加配置信息
		//指定连接的kafka集群
		props.put("bootstrap.servers", "hadoop102:9092");
		//ack应答级别
		props.put("acks", "all");
		//重试次数
		props.put("retries", 0);
		//批次大小 一次发送多少大小的数据 单位字节 大约16k 每到16k 发送到内存中，内存最大的大小是32M
		props.put("batch.size", 16384);
		//等待时间 默认1毫秒
		props.put("linger.ms", 1);
		//RecordAccumulator 缓冲区大小 32M
		props.put("buffer.memory", 33554432);
		//key value 的序列化对
		props.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
		props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");
		
		//自定义分区
		props.put("partitioner.class", "kafka.CustomerPatition");
		
		//3. 创建生产者对象
		KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
		
		//4.发送数据
		for (int i = 0; i < 10; i++) {
			
			//producer.send(new ProducerRecord<String, String>("bw", "BW--"+i));
			producer.send(new ProducerRecord<String, String>("second", "BW--"+i),new Callback() {
				
				public void onCompletion(RecordMetadata metadata, Exception exception) {
					
					if(exception==null) {
						System.out.println(metadata.partition()+"---"+metadata.offset());
					}else {
						System.out.println("发送失败");
					}
					
				}
			});
		}
		
		//5.关闭资源
		producer.close();
	}

}

结果：
在这里插入图片描述
全在0分区

因为都在0分区所以消息又有顺序了

4.3 Kafka消费者Java API

4.3.1 高级API

0）在控制台创建两个发送者，发送不同topic的消息

[atguigu@hadoop104 kafka]$ bin/kafka-console-producer.sh --broker-list hadoop102:9092 --topic first
>hello world

在这里插入图片描述

1）官方提供案例（自动维护消费情况）（新API）

package customer;

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

public class CustomerConsumer {
	public static void main(String[] args) {
		
		//1.设置配置信息
		Properties props = new Properties();
		
		// 连接kafka集群
		props.put("bootstrap.servers", "hadoop102:9092");
		//设置消费者组id
		props.put("group.id", "test");
		//设置自动提交offset
		props.put("enable.auto.commit", "true");
		//提交延时 可能会重复消费
		props.put("auto.commit.interval.ms", "1000");
		//KV的反序列化
		// key的序列化类
		props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
				// value的序列化类 
		props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

		//2.创建消费者对象
		KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(props);
		
		//指定topic 里面放一个集合的参数，说明一个消费者可以消费多个topic
		consumer.subscribe(Arrays.asList("second","first","third"));
		
		while(true) {
			
			//消费数据
			ConsumerRecords<String, String> consumerRecords = consumer.poll(100);
			
			//打印数据：
			for (ConsumerRecord<String, String> record:consumerRecords) {
				System.out.println(record.topic()+"---"+record.partition()+"---"+record.value());
			}
		}
	}
}

运行程序：成功获取信息
在这里插入图片描述

4.3.2 低级API

先打开集群102 103 104

然后开集群102 103 104的zookeeper

然后开集群102 103 104的kafka:

/opt/module/kafka/bin/kafka-server-start.sh /opt/module/kafka/config/server.properties

然后运行程序：
在这里插入图片描述

第 5 章 Kafka 监控

在这里插入图片描述

[BW@hadoop102 kafka]$ xsync bin/kafka-server-start.sh

在这里插入图片描述

[BW@hadoop102 software]$ tar -zxvf kafka-eagle-bin-1.3.7.tar.gz 
kafka-eagle-bin-1.3.7/
kafka-eagle-bin-1.3.7/kafka-eagle-web-1.3.7-bin.tar.gz

[BW@hadoop102 software]$ cd kafka-eagle-bin-1.3.7
[BW@hadoop102 kafka-eagle-bin-1.3.7]$ tar -zxvf kafka-eagle-web-1.3.7-bin.tar.gz -C /opt/module/
[BW@hadoop102 module]$ mv kafka-eagle-web-1.3.7/ eagle

[BW@hadoop102 eagle]$ pwd
/opt/module/eagle

#EAGLE_HOME
export KE_HOME=/opt/module/eagle
export PATH= $P A T H :$ KE_HOME/bin

在这里插入图片描述
source /etc/profile

[BW@hadoop102 bin]$ chmod 777 ke.sh
在这里插入图片描述

http://192.168.186.102:8048/ke

在这里插入图片描述

重点掌握：

第 6 章 Flume 对接 Kafka

为什么要flume接kafka：
生产环境中，经常将数据采集到日志文件中，而flume是日志监控框架。为啥要对接kafka？由于flume采集数据后要对接多个业务线，内存不太够，业务线上的要保证数据一致，而且不能动态增加业务线

在flume里增加配置文件

[BW@hadoop102 job]$ vim kafka.conf

#Name
a1.sources = r1
a1.sinks = k1
a1.channels = c1

# source
a1.sources.r1.type = netcat
a1.sources.r1.bind = localhost
a1.sources.r1.port = 44444
#a1.sources.r1.command = tail -F -c +0 /opt/module/data/flume.log
#a1.sources.r1.shell = /bin/bash -c

# sink
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.bootstrap.servers = hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.sinks.k1.kafka.topic = first
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = 1
a1.sinks.k1.kafka.producer.linger.ms = 1

# channel
a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000
a1.channels.c1.transactionCapacity = 100

# bind
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

在102 103 104 启动kafka

[atguigu@hadoop102 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties

然后在102创建一个消费者

[BW@hadoop102 kafka]$ bin/kafka-console-consumer.sh --zookeeper hadoop102:2181 --topic first

然后102启动flume

[BW@hadoop102 flume]$ bin/flume-ng agent -c conf/ -f job/kafka.conf -n a1

然后用netcat写信息：

[BW@hadoop102 ~]$ nc localhost 44444

在这里插入图片描述
然后查看kafka消费者是否收到信息;

还有一个数据分类的案例看新版的P42

第 7 章 Kafka 面试题

在这里插入图片描述
ISR+OSR=AR

在这里插入图片描述

区内有序

看课件

两个线程讲过

对但是生产环境下不能让这种事发生

offset从0开始存加入一个数据，提交的位移是0+1=1

8：先处理数据，后提交offset，有可能在中间挂了，消费了数据，但是没有提交offset 下一次又来一遍，导致重复消费，
9：先提交offset 后处理数据
在这里插入图片描述

可增不可减
不可减：已经存在的数据无法处理

有， consumeroffsets 作用：给普通的消费者存offset

两种：range(按照主题划分) round…（按照消费者组，进行轮询分）

index和log 如何找到具体的数据：

在这里插入图片描述
第一步通过二分查找法定位index文件然后扫描这个文件
找到这个数据在log里面具体的偏移量

（问的比较少）相当于临时选举的老大。当元数据更新时，通知别的节点保持一致
等

在这里插入图片描述
两处地方：controller（原则比较简单：抢资源）和leader （原则 ISR 一个看同步的时间一个看同步的条数）

ISR

分布式
顺序写磁盘
零拷贝

bw_ustc

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Kafka 学习

20.1.30 Kafka 学习第 1 章 Kafka 概述1.1 定义1.2 消息队列1.2.1 传统消息队列的应用场景1.2.2 消息队列的两种模式1.3 Kafka 基础架构第 2 章 Kafka 快速入门第 1 章 Kafka 概述1.1 定义只要使用spark，那么百分之90的数据来源于kafka,其对于实时性的很重要。1.2 消息队列1.2.1 传统消息队列的应用场景...
复制链接

扫一扫