kafka3.x入门教程（四）

已于 2023-01-14 23:21:41 修改
阅读量1.2k 收藏 3
点赞数
分类专栏： mq springboot linux 文章标签： kafka Powered by 金山文档
于 2023-01-14 15:20:14 首次发布
原文链接：https://blog.csdn.net/qq_21277357/article/details/128684275?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22128684275%22%2C%22source%22%3A%22qq_21277357%22%7D
版权
springboot 同时被 3 个专栏收录
89 篇文章 2 订阅
订阅专栏
linux
50 篇文章 1 订阅
订阅专栏
mq
29 篇文章 0 订阅
订阅专栏

接下来我们来看下kafka的副本

kafka的副本作用：就是提高数据的可靠性

kafka的默认副本1个，生产环境一般配置为2个，太多的副本会

增加磁盘存储空间，增加网络上数据传输，降低效率

kafka的副本分为leader和follower,生产者只会把数据发送给leader,然后follower找leader

同步数据

kafka中所有的副本统称AR

AR=ISR+OSR

ISR:表示和leader保持同步的follower集合，如果follower长时间未向leader发送通信请求

或者同步数据，那么把follwer剔除isr，放入osr,默认超时时间是30秒，

leader发送故障之后，就会从isr中选举新的leader

OSR:表示follower与leader副本同步时，延迟过多的副本；

接下来我们在来看下leader的选举流程

1:broker启动后在zk注册

2：controller谁先注册，谁说了算

3：由选举出来的controller监听brokers节点变化

4：controller决定leader选举，

选举规则：在isr中存活为前提，按照ar中排在前面的优先；

例如ar[1,0,2],isr[1,0,2],那么leader就会按照1,0,2的顺序轮训

5：controller将节点信息上传到zk

6: 其他controller从zk同步相关信息

7：假设broker1中leader挂了

8：controller监听到节点变化

9：获取isr

10:选择新的leader,在isr存活为前提，ar中排在前面的优先

11：更新leader和isr

创建一个新的主题为zt,3个分区，3个副本

cd /opt/kafka

bin/kafka-topics.sh --bootstrap-server linux1:9092 --create --topic zt --partitions 3 --replication-factor 3

查看下主题的详情

bin/kafka-topics.sh --bootstrap-server linux1:9092 --describe --topic zt

我们可以看到在leader1节点后面是2，按照的是ar优先的

我们把leader1停掉，就是linux2这台机器

cd /opt/kafka/
./bin/kafka-server-stop.sh

我们在看下主题的详情，可以看到leader2上位了，isr踢出了1

我们在恢复1

./bin/kafka-server-start.sh -daemon config/server.properties

再次查看主题详情，可以看到isr已经恢复回来了

接下来我们在来看下leader和Follwer故障处理细节

leader会先收到数据，数据会多一些

follower同步数据，会少一些

假设leader数据是 0 1 2 3 4 5 6 7(offset)

follower 是0 1 2 3 4(offset)

follower 是0 1 2 3 4 5(offset)

LEO:每个副本的最后一个offset,LEO就是最新的offset+1;

HW:所有副本中最小的LEO,就是leader的4,follower的4,follower的4

follower故障

1：follower发送故障后会被临时提出isr

2: 这个期间leader和follower继续接收数据

3：等到follower恢复后，follower会读取本地磁盘纪录的上次hw,

并将log文件高于hw的部分截取掉，从hw开始向leader进行同步

4：等该followe的leo大于等于该分区的hw,则follower追上leader之后，

就可以重新加入isr了

Leader故障处理细节

1：leader发送故障之后，会从isr中选出一个新的leader

2:为保证多个副本之间的数据一致性，其余的follower会先将

各自的log文件高于hw的部分截掉，然后从新的leader同步数据

注意：这只能保证副本之间的数据一致性，并不能保证数据不丢失或者不重复

接下来我们来看下分区副本分配

创建主题为sl,16个分区，3个副本

 bin/kafka-topics.sh --bootstrap-server linux1:9092 --create --partitions 16 --replication-factor 3 --topic sl

查看主题详情

bin/kafka-topics.sh --bootstrap-server linux1:9092 --describe --topic sl

可以看到分区和副本的情况

接下来我们手动分配分区副本

把主题sl的0,1,2,3分区 都设置副本为0,1

cd /opt/kafka 
vim increase-replication-factor.json
{
"version":1,
"partitions":[{"topic":"sl","partition":0,"replicas":[0,1]},
{"topic":"sl","partition":1,"replicas":[0,1]},
{"topic":"sl","partition":2,"replicas":[1,0]},
{"topic":"sl","partition":3,"replicas":[1,0]}]
}

执行副本存储计划

bin/kafka-reassign-partitions.sh --bootstrap-server linux1:9092 --reassignment-json-file increase-replication-factor.json --execute

验证副本存储计划

bin/kafka-reassign-partitions.sh --bootstrap-server linux1:9092 --reassignment-json-file increase-replication-factor.json --verify

再次查看主题详情

bin/kafka-topics.sh --bootstrap-server linux1:9092 --describe --topic sl

可以看到已经发送了变化

kafka文件存储机制

Topic是逻辑上的概念，而partition是物理上的概念，每个partition对应于一个log文件，该log文件中存储的就是Producer生产的数据。

Producer生产的数据会被不断追加到该log文件末端，为防止log文件过大导致数据定位效率低下，Kafka采取了分片和索引机制，将每个partition分为多个segment。

每个segment包括：“.index”文件、“.log”文件和.timeindex等文件。这些文件位于一个文件夹下，该文件夹的命名规则为：topic名称+分区序号，例如：zhuti-0。

cd /opt/kafka/datas

可以看到下面的就是主题+分区序号

进入其中一个目录，可以看到index,log,timeindex文件

如果直接使用cat是看不到的，使用下面的命令

kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000000.index
kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000000.log
kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000000.timeindex

kafka的数据默认存储7天，7天后自动删除

高效读写数据

1：kafka本身是分布式集群，可以采用分区技术，并行度高

2：读数据采用稀疏索引，可以快速定位要消费的数据

3：顺序写磁盘

4：页缓存+零拷贝技术

kafka消费方式

pull(拉取)模式:消费者从broker中主动拉取数据，kafka采用这种方式

push(推送)模式：kafka没有采用这种方式，因为broker决定消息发送速率，

很难适应所有消费者的消费速率，例如推送的速度是50m/s，

消费者1，消费者2就来不及处理消息

pull模式不足之处是,如果kafka没有数据,消费者可能会陷入循环中，一直返回空数据

消费组

消费组由多个消费者组成，所有消费者的groupid相同；

消费者组内每个消费者负责消费不同分区的数据，一个分区只能由一个组内的消费者消费

消费者组之间互不影响，所有的消费者都属于某个消费者组，消费者组是逻辑上的一个订阅者

在消费者代码中必须配置消费者组id,在使用命令行的时候不用写，他底层自动生成了随机的消费者组id

接下来我们创建消费者的代码

package com.example.client.entity;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 *
 * 消费者
 * @param
 * @return
 * @throws Exception
 */
public class Consumer {
    public static void main(String[] args) {
        //创建生产者的配置对象
        Properties properties=new Properties();
        //给kafka配置对象添加配置信息    bootstrap.serve
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"linux1:9092,linux2:9092,linux3:9092");
        //key value 反序列化  生产者发送的数据序列化,那么我们这里就要反序列化
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        //配置消费者组 必须 随便起名字
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"group_id");
        //创建消费者对象
        KafkaConsumer<String,String>kafkaConsumer=new KafkaConsumer<String, String>(properties);
        //注册要消费的主题
        List<String>list=new ArrayList<>();
        //主题的名字
        list.add("zt");
        //订阅主题
        kafkaConsumer.subscribe(list);
        //拉取数据打印
        while (true){
            //设置1秒消费一批数据    poll 拉取模式
            ConsumerRecords<String,String>consumerRecords=kafkaConsumer.poll(Duration.ofSeconds(2));
            //打印消费到的数据
            for (ConsumerRecord<String, String> x : consumerRecords) {
                System.out.println(x);
            }
        }


    }
}

先启动消费者，在启动生产者，可以看到消费到数据了

接下来我们来看下消费某一个分区的代码

先对生产者改造

package com.example.client.entity;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.UUID;
import java.util.concurrent.ExecutionException;

//生产者
public class Producer {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建生产者的配置对象
        Properties properties=new Properties();
        //给kafka配置对象添加配置信息    bootstrap.serve
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"linux1:9092,linux2:9092,linux3:9092");
        //key value序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

       //设置事物id
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "shiwu_id");
        //acks级别
        properties.put(ProducerConfig.ACKS_CONFIG,"-1");
        //重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,3);
        //使用幂等性
        properties.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,"true");


        //创建kafka生产者对象
        KafkaProducer<String,String>kafkaProducer=new KafkaProducer<String, String>(properties);
        //初始化事物
        kafkaProducer.initTransactions();
        //开启事物
        kafkaProducer.beginTransaction();

        //调用send方法 发送消息
           try {
               for (int i = 0; i < 5; i++) {
                   //给zhuti这个主题 发送消息
                   ProducerRecord<String, String> var1=new ProducerRecord("zt",0,"","你好");
                   kafkaProducer.send(var1, new Callback() {
                       //异步回调 完成时
                       @Override
                       public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                           if(e==null){
                               System.out.println("主题:"+recordMetadata.topic()+",分区:"+recordMetadata.partition());
                           }else {
                               //打印异常信息
                               e.printStackTrace();
                           }
                       }
                   });
               }
               //模拟报错
              // int a=1/0;
               //提交事物
               kafkaProducer.commitTransaction();
           }catch (Exception e){
               //终止事物
               kafkaProducer.abortTransaction();
           }
        //关闭资源
        kafkaProducer.close();
    }
}

主要就是生产者发送到0号分区

package com.example.client.entity;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 *
 * 消费者
 * @param
 * @return
 * @throws Exception
 */
public class Consumer {
    public static void main(String[] args) {
        //创建生产者的配置对象
        Properties properties=new Properties();
        //给kafka配置对象添加配置信息    bootstrap.serve
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"linux1:9092,linux2:9092,linux3:9092");
        //key value 反序列化  生产者发送的数据序列化,那么我们这里就要反序列化
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        //配置消费者组 必须 随便起名字
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"group_id");
        //创建消费者对象
        KafkaConsumer<String,String>kafkaConsumer=new KafkaConsumer<String, String>(properties);
        //主题分区
        List<TopicPartition>list=new ArrayList<>();
        //主题的名字  消费的分区
        TopicPartition topicPartition=new TopicPartition("zt",0);
        list.add(topicPartition);
        //分配
        kafkaConsumer.assign(list);
        //拉取数据打印
        while (true){
            //设置1秒消费一批数据    poll 拉取模式
            ConsumerRecords<String,String>consumerRecords=kafkaConsumer.poll(Duration.ofSeconds(1));
            //打印消费到的数据
            for (ConsumerRecord<String, String> x : consumerRecords) {
                System.out.println(x);
            }
        }


    }
}

我们创建2个消费者，代码都一样

生产者在这里发送不同的分区

启动消费者，在启动生产者

可以看到一个消费者组，每个消费者只能消费一个分区的数据

如果生产者发送的数据，造成了数据积压怎么办？

1：增加消费者数，增加分区数，两者保持一致，一个消费者对应一个分区

2：提高每批次拉取数量

接下来我们在来看下Kafka-Eagle监控

Kafka-Eagle可以监控kafka集群的整体运行情况

先安装mysql 主要用来存储可视化展示的数据

docker run -d -p 13306:3306 --privileged=true -v /root/mysql/log:/var/log/mysql -v /root/mysql/data:/var/lib/mysql -v /root/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql57 mysql:5.7

关闭所有kafka,调整jvm

cd /opt/kafka
./bin/kafka-server-stop.sh
cd /opt/kafka/bin
vim kafka-server-start.sh

把export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"注释掉

然后添加下面的内容

export KAFKA_HEAP_OPTS="-server -Xms2G -Xmx2G 
-XX:PermSize=128m
-XX:+UseG1GC 
-XX:MaxGCPauseMillis=200 
-XX:ParallelGCThreads=8 
-XX:ConcGCThreads=5 
-XX:InitiatingHeapOccupancyPercent=70"
export JMX_PORT="9999"

再次启动所有kafka

cd /opt/kafka
./bin/kafka-server-start.sh -daemon config/server.properties

接下来安装Kafka-Eagle

访问https://www.kafka-eagle.org/

下载kafka-eagle-bin-2.0.8.tar.gz

上传到/opt目录

解压

tar -zxvf kafka-eagle-bin-2.0.8.tar.gz
cd kafka-eagle-bin-2.0.8/
tar -zxvf efak-web-2.0.8-bin.tar.gz
mv efak-web-2.0.8 efak

修改配置文件

cd /opt/kafka-eagle-bin-2.0.8/efak/conf
vi system-config.properties

主要关注箭头的位置去修改

注释这里

配置数据库

保存退出

添加环境变量

 vi /etc/profile
# kafkaEFAK
export KE_HOME=/opt/kafka-eagle-bin-2.0.8/efak
export PATH=$PATH:$KE_HOME/bin

刷新环境变量

source /etc/profile

启动efak

cd /opt/kafka-eagle-bin-2.0.8/efak
./bin/ke.sh start

停止efak

cd /opt/kafka-eagle-bin-2.0.8/efak
./bin/ke.sh stop

前置环境要安装好jdk1.8,java_home要有环境变量，不能用系统自带的

浏览器访问

http://192.168.1.5:8048/

账号admin

密码123456

可以看到主题的信息

在这里还可以创建主题的信息

在这个位置可以看到图表信息

接下来我们在看下kraft模式

就是不用在使用zookeeper了，kafka可以独立运行，不需要从zk中读取数据了

我们把所有的kafka都停掉

cd /opt/kafka/
./bin/kafka-server-stop.sh

然后进入kraft目录

cd /opt/kafka/config/kraft
vi server.properties

我们按照ip来区分节点id

node.id=5

controller.quorum.voters=5@linux1:9093,6@linxu2:9093,7@linux3:9093

这里改一下

# broker对外暴露的地址

advertised.listeners=PLAINTEXT://linux1:9092

这里改一下

#数据存储目录

log.dirs=/opt/kafka/data

其他2个ip node.id=6,node.id=7 其他配置都一样

先在第一台机器生成存储目录唯一id

cd /opt/kafka
bin/kafka-storage.sh random-uuid

拿着这个uuid

MQIfWd38RWuohebCszAneA

在三台节点上面格式化kafka存储目录

bin/kafka-storage.sh format -t MQIfWd38RWuohebCszAneA -c /opt/kafka/config/kraft/server.properties

在三台机器上面启动kafka,注意 启动是kraft目录的server.properties

bin/kafka-server-start.sh -daemon config/kraft/server.properties

我们来创建一个主题aaa

cd /opt/kafka/
bin/kafka-topics.sh --bootstrap-server linux1:9092 --create --partitions 1 --replication-factor 3 --topic aaa

发送下消息

bin/kafka-console-producer.sh --bootstrap-server linux1:9092 --topic aaa

在来消费一条消息

bin/kafka-console-consumer.sh --bootstrap-server linux1:9092 --topic aaa

可以看到收到消息了

kafka3.x入门教程（五）

我是一只代码狗
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kafka系列之：统计kafka集群Topic的分区数和副本数，批量增加topic副本数
zhengzaifeidelushang的博客
12-12 860
Kafka系列之：统计kafka集群Topic的分区数和副本数，批量增加topic副本数
kafka集群及副本的概念
weixin_45809829的博客
06-26 999
kafka集群及副本的概念
Kafka-副本数量设置
qq_40382400的博客
08-05 4409
ISR 机制的另外一个相关参数是, 可以在 broker 或者主题级别进行配置，代表 ISR 列表中至少要有几个可用副本。这里假设设置为 2，那么当可用副本数量小于该值时，就认为整个分区处于不可用状态。此时客户端再向分区写入数据时候就会抛出异常。
Kafka-核心架构-分区、副本（含副本选举机制）
最新发布
喻师傅的学习笔记
05-16 1565
Kafka分区和副本
Kafka ACK应答级别以及相关副本介绍
qq_36570086的博客
06-21 643
kafka中副本介绍以及相关作用
Kafka3.x从入门到精通.xmind
01-04
Kafka3.x从入门到精通.xmind
kafka教程.pdf
04-18
Apache Kafka是一个分布式流处理平台，由LinkedIn公司开发并开源。它主要用于构建实时数据流管道和应用。它可以处理消费者网站的所有动作流数据，包括页面访问量、搜索以及其他用户行为等。这些数据通常被用于实时...
kafka 3.x基础笔记，基础技术，环境搭建，外部集成，生产调优，源码解析
05-06
**Kafka 3.x 基础知识** Kafka 是一个分布式的流处理平台，由 Apache 软件基金会开发并维护。它最初由 LinkedIn 开发，后来成为开源项目，并迅速成为了实时数据处理领域的热门选择。Kafka 3.x 版本在前一版本的基础...
Kafka入门.pdf
03-19
Kafka入门，非常详细
kafka最新版本2.8.X安装全套包
11-26
chown kafka.kafka /var/log/kafka/` 5. 启动 Kafka：`bin/kafka-server-start.sh config/server.properties` **创建 Topic** 在 Kafka 中，数据以主题（topics）的形式存在。创建一个主题的命令如下： ``` bin/...
Kafka
qq_66455465的博客
04-18 160
会根据 seq 重 新添加到队列的合适位置，并把 max.in.flight.requests.per.connection 设为。情况下 max.in.flight.requests.per.connection。replica.lag.time.max.ms= 600000# 如果网络不好。败，就会无限次重试，保证数据必须成功的发送给两个副本，如果做不到，就不停。的重试，除非是面向金融级的场景，面向企业大客户，或者是广告计费，跟钱的计。官网有数据表明，同样的磁盘，顺序写能到。
Kafka系列 - 09 Kafka副本|Leader选举流程|Follower故障|Leader故障
你今天真好看呀
11-29 1521
Partition为2的分区有4个副本，其中 Leader为3，假如 hadoop104 挂掉了，那么Partition为2 的Leader 就会重新选举，选举的规则为：在 ISR 中存活为前提，按照AR中排在前面的优先，即新的Leader将是1。Partition为1的分区有4个副本，其中 Leader为2，假如 hadoop103 挂掉了，那么Partition为2 的Leader 就会重新选举，选举的规则为：在 ISR 中存活为前提，按照AR中排在前面的优先，即新的Leader将是1。
kafka broker详解
qq_38016945的博客
02-09 580
Topic是逻辑上的概念，而partition是物理上的概念，每个partition对应于一个log文件，该log文件中存储的就是Producer生产的数据。Producer生产的数据会被不断追加到该log文件末尾，为防止log文件过大导致数据定位效率低下，Kafka采取了分片和索引机制，将每个partition分为多个segment。2）为保证多个副本之间的数据一致性，其余的Follower会先将各自的log文件高于HW的 部分截掉，然后从新的Leader同步数据。
[kafka]三.生产环境|压测|分区数|副本数|节点数|topic数|数据量计算|硬盘大小|日志保存时间|kafka监控
胖胖的博客
10-31 840
kafka官方自带压力测试脚本:kafka-consumer-pref-test.sh kafka-preducer-pref-test.sh。假如Producer的吞吐量=20m/s，Consumer的吞吐量=50m/s。kafka的机器数量（经验公式）=2*（峰值速度m/s*副本数/100）+1。比如压力测试写入（生产）速度为10m/s每台，峰值为50m/s，副本数为2。每天的数据量100G*2个副本*3天/70%=600G/0.7=900G。kafka节点数量=2*（50*2/100）+1=3台。
Kafka高级(1) -- kafka分区与副本机制
erainm
09-16 1209
1. 生产者分区写入策略 轮询分区策略、 随机分区策略、按key分区分配策略、自定义分区策略 2. 消费者组Rebalance机制 Rebalance再均衡、Rebalance的不良影响 3. 消费者分区分配策略 Range范围分配策略、 RoundRobin轮询策略、 Stricky粘性分配策略 4. 副本机制 producer的ACKs参数、acks配置为0、acks配置为1、acks配置为-1或all
Kafka的数据可靠与数据重复
Laoddaaa的博客
08-10 643
kafka数据重复及数据可靠性问题
kafka的副本以及分区与副本的关系
热门推荐
健康平安的活着的专栏
03-06 1万+
一 副本的作用 1.Kafka 副本作用：提高数据可靠性。 2.Kafka 中副本分为：Leader 和 Follower。Kafka 生产者只会把数据发往 Leader， 然后 Follower 找 Leader 进行同步数据。 读写由leader来完成，follower只备份，和leader同步数据，leader发生故障，follower顶上去。 leader副本：可以理解为某个分区中，除了不是副本的那个分区。 3.Kafka 分区中的所有副本统称为 AR（Assigned Repllica
kafka日常操作（包含修改分区，副本数）
a13568hki的博客
03-23 2675
增加新服务到kafka集群是很容易的，只要为新服务分配一个独一无二的Broker ID并启动即可。但是，新的服务不会自动分配到任何数据，需要把分区数据迁移给它们，在此期间它们一直不工作，直到新的topic创建，所以，通常向集群添加机器时，你需要将一些现有的数据迁移到这些机器上。 迁移数据的过程是手动启动的，但是执行过程是完全自动化的。在kafka后台内部中，kafka将添加新的服务器，并作为正在迁移分区的follower，来完全复制该分区现有的数据。当新服务器完全复制该分区的内容并加入同步副本，成为现有副本
wurstmeister/kafka 2.3设置默认副本数
johnhuster的专栏
01-25 2160
kafka是使用十分广泛的一款消息中间件，凭借其强大的吞吐以及可靠性获得了不错的口碑，其在大数据传输方面也有应用，wurstmeister/kafka是目前使用最多的一个kafka docker镜像。kafka的副本数在kafka的高可用性上有着至关重要的作用，笔者的一篇文章中说到了可以通过KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR设置__consumer_offsets主题的副本数，__consumer_offsets主题是用来存储其他主题各个分区消费进度的主题，这是ka
Kafka深度解析：从入门到实践的完整教程
Kafka学习非常详细的经典教程深入讲解了Kafka这一分布式消息系统的核心概念和技术细节。Kafka的特点在于其可分区、可复制的设计，使得消息的发布和消费更为高效和灵活。 首先，Kafka的基本概念包括： 1. **Topic**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值