Spark阶段总结

最新推荐文章于 2024-08-02 19:47:45 发布

dogedong

最新推荐文章于 2024-08-02 19:47:45 发布

阅读量2k

点赞数 1

分类专栏： # 大数据优就业——第三阶段（spark生态系统体系架构）笔记文章标签： spark kafka big data

本文链接：https://blog.csdn.net/qq_36972345/article/details/121350939

版权

kafka消费数据同一时刻，kafka当中数据只能被一个消费者组下面的一个消费者所消费。kafka消费者在消费数据的时候，都是分组别的。不同组的消费不受影响，相同组内的消费，需要注意，如果partition有3个，消费者有3个，那么便是每一个消费者消费其中一个partition对应的数据；如果有2个消费者，此时一个消费者消费其中一个partition数据，另一个消费者消费2个partition的数据。如果有超过3个的消费者，同一时间只能最多有3个消费者能消费得到数据，kaf.

摘要由CSDN通过智能技术生成

Kafka

kafka消费数据

同一时刻，kafka当中数据只能被一个消费者组下面的一个消费者所消费。

kafka消费者在消费数据的时候，都是分组别的。不同组的消费不受影响，相同组内的消费，需要注意，如果partition有3个，消费者有3个，那么便是每一个消费者消费其中一个partition对应的数据；如果有2个消费者，此时一个消费者消费其中一个partition数据，另一个消费者消费2个partition的数据。如果有超过3个的消费者，同一时间只能最多有3个消费者能消费得到数据，

kafka当中数据的顺序性

如果将数据保存到多个分区当中，只能保证分区之内有序，全局无序；

要想全局有序，将所有数据发送到一个分区当中。

kafka生产者生产数据

指定topic+value：数据采用轮询模式保存

指定topic+key+value：如果key是固定死的，利用key的hash将数据发送某一个分区当中；如果key是动态的，也是利用key的hash，将数据发送到指定分区当中。

指定topic+partition+key+value：如果指定了分区数，那么就会将所有数据发送到指定分区当中。

Produce端向broker端发送数据并保存，为了防止发送的数据丢失，有ack机制，ack机制一共分为3种：

0：producer端发送数据，不管leader是否保存成功，follower是否同步成功，继续发送下一批数据；

1：producer端发送数据，保证leader保存成功，不管follower是否同步成功，继续发送下一批数据；

-1：producer端发送数据，既要保证leader保存成功，也要保证follower同步成功，再发送下一批数据。

## kafka的服务器
bootstrap.servers=bd-offcn-01:9092,bd-offcn-02:9092,bd-offcn-03:9092
##Key的序列化器
key.serializer=org.apache.kafka.common.serialization.IntegerSerializer 
##value的序列化器
value.serializer=org.apache.kafka.common.serialization.StringSerializer 
acks=[0|-1|1|all] ##消息确认机制
	0:	不做确认，直管发送消息即可
	-1|all: 不仅leader需要将数据写入本地磁盘，并确认，还需要同步的等待其它followers进行确认
	1:只需要leader进行消息确认即可，后期follower可以从leader进行同步
batch.size=1024 #每个分区内的用户缓存未发送record记录的空间大小
## 如果缓存区中的数据，没有占满，也就是任然有未用的空间，那么也会将请求发送出去，为了较少请求次数，我们可以配置linger.ms大于0，
linger.ms=10 ## 不管缓冲区是否被占满，延迟10ms发送request
buffer.memory=10240 #控制的是一个producer中的所有的缓存空间
retries=0 #发送消息失败之后的重试次数

kafka消费的并行度就是kaka topic分区的个数，或者分区的个数决定了同一时间同一消费者组内最多可以有多少个消费者消费数据

offset：是kafka的topic中的partition中的每一条消息的标识，如何区分该条消息在kafka对应的partition的位置，就是用该偏移量。offset的数据类型是Long，8个字节长度。offset在分区内是有序的，分区间是不一定有序。

多节点partition存储分布

副本分配算法：

将所有N Broker和待分配的i个Partition排序。
将第i个Partition分配到第(i mod n)个Broker上。
将第i个Partition的第j个副本分配到第((i + j) mod n)个Broker上。
同时也要兼顾复杂均衡，尽量在所有的节点里面都保存相同多的分区及其副本。

segment文件段

在kafka中，一个主题可以有多个分区；一个分区可以有多个segment文件段，一个segment文件段有两个文件：.log、.index文件。

.log文件保存数据，.index文件保存数据当中的索引，是稀疏索引。

一个segment文件段默认保存1g数据，当中segment文件段达到1g的数据量，就要开始分裂出第二个segment文件段，以此类推。

第一个segment文件段：

-rw-r--r-- 1 root root 10485760 Oct 13 17:14 00000000000000000000.index

-rw-r--r-- 1 root root 654696 Oct 13 17:14 00000000000000000000.log

第二个segment文件段：

-rw-r--r-- 1 root root 10485760 Oct 13 17:14 00000000000000004356.index

-rw-r--r-- 1 root root 654696 Oct 13 17:14 00000000000000004356.log

第三个segment文件段：

-rw-r--r-- 1 root root 10485760 Oct 13 17:14 00000000000000752386.index

-rw-r--r-- 1 root root 654696 Oct 13 17:14 00000000000000752386.log

Segment文件段命名规则：

以当前segment文件段当中.log文件中第一条数据的偏移量命名。

Kafka中的push和pull

push模式很难适应消费速率不同的消费者，因为消息发送速率是由broker决定的。push模式的目标是尽可能以最快速度传递消息，但是这样很容易造成consumer来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而pull模式则可以根据consumer的消费能力以适当的速率消费消息。
pull模式不足之处是，如果kafka没有数据，消费者可能会陷入循环中，一直返回空数据。针对这一点，Kafka的消费者在消费数据时会传入一个时长参数timeout，如果当前没有数据可供消费，consumer会等待一段时间之后再返回，这段时长即为timeout。

kafka为什么那么快

顺序读写磁盘
采用pageCache页缓存技术
多目录

Kafka命令

启动集群

依次在 hadoop102、hadoop103、hadoop104 节点上启动 kafka
[atguigu@hadoop102 kafka]$ bin/kafka-server-start.sh config/server.properties &
[atguigu@hadoop103 kafka]$ bin/kafka-server-start.sh config/server.properties &
[atguigu@hadoop104 kafka]$ bin/kafka-server-start.sh config/server.properties &

关闭集群

[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

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

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

创建 topic

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

选项说明： --topic 定义 topic 名 --replication-factor 定义副本数 --partitions 定义分区数

删除 topic

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

发送消息

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

消费消息

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

--from-beginning：会把 first 主题中以往所有的数据都读取出来。根据业务场景选择是否增加该配置。

查看某个 Topic 的详情

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

启动消费者

[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 --zookeeper hadoop102:2181 
--topic first --consumer.config config/consumer.properties

Kafka API

package com.atguigu.kafka;
import java.util.Properties;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
public class NewProducer {
public static void main(String[] args) {
Properties props = new Properties();
// Kafka 服务端的主机名和端口号
props.put("bootstrap.servers", "hadoop103:9092");
// 等待所有副本节点的应答
props.put("acks", "all");
// 消息发送最大尝试次数
props.put("retries", 0);
// 一批消息处理大小
props.put("batch.size", 16384);
// 请求延时
props.put("linger.ms", 1);
// 发送缓存区内存大小
props.put("buffer.memory", 33554432);
// key 序列化
props.put("key.serializer", 
"org.apache.kafka.common.serialization.StringSerializer");
// value 序列化
props.put("value.serializer", 
"org.apache.kafka.common.serialization.StringSerializer");
Producer<String, String> producer = new KafkaProducer<>(props);
for (int i = 0; i < 50; i++) {
producer.send(new ProducerRecord<String, String>("first", 
Integer.toString(i), "hello world-" + i));
}
producer.close();
}
}

自定义分区生产者

定义一个类实现 Partitioner 接口，重写里面的方法（过时 API）

package com.atguigu.kafka;
import java.util.Map;
import kafka.producer.Partitioner;
public class CustomPartitioner implements Partitioner {
public CustomPartitioner() {
super();
}
@Override
public int partition(Object key, int numPartitions) {
// 控制分区
return 0;
}
}

Kaka消费者api

#1、地址
bootstrap.servers=node01:9092
#2、序列化 
key.serializer=org.apache.kafka.common.serialization.StringSerializer value.serializer=org.apache.kafka.common.serialization.StringSerializer
#3、主题（topic） 需要制定具体的某个topic（order）即可。
#4、消费者组 group.id=test
public class OrderConsumer {
public static void main(String[] args) {
// 1\连接集群
Properties props = new Properties(); 
props.put("bootstrap.servers", "node01:9092"); 
props.put("group.id", "test");
//以下两行代码 ---消费者自动提交offset值 
props.put("enable.auto.commit", "true"); 
props.put("auto.commit.interval.ms",  "1000");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
 
KafkaConsume

最低0.47元/天解锁文章

dogedong

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Spark阶段总结

kafka消费数据同一时刻，kafka当中数据只能被一个消费者组下面的一个消费者所消费。kafka消费者在消费数据的时候，都是分组别的。不同组的消费不受影响，相同组内的消费，需要注意，如果partition有3个，消费者有3个，那么便是每一个消费者消费其中一个partition对应的数据；如果有2个消费者，此时一个消费者消费其中一个partition数据，另一个消费者消费2个partition的数据。如果有超过3个的消费者，同一时间只能最多有3个消费者能消费得到数据，kaf.
复制链接

扫一扫

专栏目录