Kafka-学习笔记分享


前言

本文分享本菜鸟的Kafka学习笔记,Kafka作为现在比较火热的消息队列,学习Kafka还是相当有意义的。有任何问题都可以与本菜鸟讨论、学习。一起学习,一起进步。
本菜鸟QQ:599903582
笨鸟先飞,熟能生巧。
比心心~


提示:以下是本篇文章正文内容,下面案例可供参考

1.定义

Kafka是一个分布式的基于发布/订阅模式的消息队列,主要应用于数据实时处理领域.

消息队列的两种模式:

  • 点对点模式:(一对一,消费者主动拉取数据,消息收到后消息清除)
  • 发布/订阅模式:(一对多,消费者消费数据之后不会清除消息)

每个partition对应一个consumer.


2.Kafka基本架构

在这里插入图片描述

  • Producer:消息生产者

  • Consumer:消息消费者

  • Consumer Group:消费者组,有多个consumer组成

  • Broker:一台服务器就是一个broker.

  • Topic:理解为一个队列,一个队列可以分为多个partition.

  • Replica:副本,故障时该节点上的partition数据不丢失,且Kafka依然能够继续工作.分为一个leader和若干follower

  • Leader:每个分区多个副本汇总的’主’,生产者发送数据的对象,以及消费者消费数据源的对象都是Leader.

  • Follower:每个分区多个副本中的’从’,实时从leader中同步数据,保持和Leader数据的同步,

    注意:Leader故障时,某个Follwer会成为新的Leader.


3.Kafka命令行操作

查看当前服务器中的所有topic
bin/kafka-topics.sh --zookeeper hadoop102:2181 --list

创建topic
bin/kafka-topics.sh --zookeeper hadoop102:2181 --create --replication-factor 3 --partitions 1 --topic first
--topic 定义 topic名
--replication-factor  定义副本数
--partitions  定义分区数

启动kafka:
    编写脚本文件:kkstart.sh
 #!/bin/bash
for i in hadoop102 hadoop103 hadoop104
do
        echo "================           $i             ================"
        ssh $i 'source /etc/profile && /opt/module/kafka/bin/kafka-server-start.sh -daemon /opt/module/kafka/config/server.properties'
done



删除topic
    bin/kafka-topics.sh  --zookeeper hadoop102:2181 --delete --topic first
需要server.properties中设置delete.topic.enable=true否则只是标记删除。

发送消息:
    bin/kafka-console-producer.sh --broker-list hadoop102:9092 --topic first
    
消费消息:
    bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --from-beginning --topic first
    
    bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --from-beginning --topic first

查看某个Topic的详情
    bin/kafka-topics.sh --zookeeper hadoop102:2181 --describe --topic first

修改分区数:
    bin/kafka-topics.sh --zookeeper hadoop102:2181 --alter --topic first --partitions 6
    

4.Kafka工作流程

在这里插入图片描述
Kafka中信息是以topic进行分类的,生产者生产消息,消费者消费消息,都是面向topic的。

    topic是逻辑上的概念,而partition是物理上的概念,每个partition对应一个log文件,该文件中存储的就是producer生产的数据.Producer生产的数据会被不断追加到该log文件末端,且每条数据都有自己的offset.消费者组中的每一个消费者,都会实时记录自己消费到哪个offset,一旦出错恢复,从上次的位置继续消费。


5.topic的存储架构

在这里插入图片描述

  • .index .log文件命名规则 : topic名称 + 分区序号
  • .index 文件 存储大量的索引信息,文件中的元数据指向对应数据文件中的message的物理偏移地址
  • .log 文件 存储大量的数据,(被序列化过的数据)

6.index文件和log文件详解

在这里插入图片描述
    offset与文件名进行比较,若是offset > 0 且 offset < 6,则在0000000000.index文件中进行 offset - 0,得到offset与 第一个message的偏移量,然后通过偏移量找到.index文件中的元数据,然后根据元数据找到.log文件中的message文件;


7.分区

原因:1.方便在集群中拓展 2.可以提高并发

分区方式:需要将Producer发送的数据封装成一个ProducerRecord对象,然后再进行分区。
在这里插入图片描述

  1. 指明partition时,直接就用指定的partition分区. (容易造成人为的数据倾斜)
  2. 指明key,未知名partition,根据key的hash值与topic的partition数进行区域得到partition值.
  3. 没有指定partition和key,默认的第一次调用随机生成一个整数(后面每次调用在这个整数上自增),将这个值与topic可用的partition总数取余得到partition值,也就是常说的round-robin算法.

分区分配策略:

  • round robin:(顺序消费,按顺序每个消费者依次取一个)
  • range(): 分区数/consumer数 = 整数 …余数 前几个分区放 整数+ 1个 ,后面的放整数个;

8.数据的可靠性(副本)

在这里插入图片描述
Kafka采用第二种措施,在所有Follower同步完成,在发送ack。


9.ISR

    Leader维护了一个动态的in-sync replica set (ISR),意为和leader保持同步follower集合。当ISR中的follower完成数据的同步之后,leader就会给producer发送ack。如果follower长时间未向leader同步数据,则该follower将被踢出ISR,该时间阈值由replica.lag.time.max.ms参数设定。Leader发生故障之后,就会从ISR中选举新的leader。


10.ack应答机制

ack三个级别:

  • 0 : producer不等待broker的ack
  • 1 : producer等待broker的ack,partition的leader落盘成功后返回ack
  • -1 : producer等待broker的ack,partition的leader和follower全部落盘才返回ack; 如果在follower同步完成后,broker发送ack之前,leader故障,那么会造成数据重复.

11.故障处理

在这里插入图片描述
1.Follower故障
  follower发生故障后会被临时踢出ISR,待该follower恢复后,follower会读取本地磁盘记录的上次的HW,并将log文件高于HW的部分截取掉,从HW开始向leader进行同步。等该follower的LEO大于等于该Partition的HW,即follower追上leader之后,就可以重新加入ISR了。

2.Leader故障
  leader发生故障之后,会从ISR中选出一个新的leader,之后,为保证多个副本之间的数据一致性,其余的follower会先将各自的log文件高于HW的部分截掉,然后从新的leader同步数据。

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


12.实现Exactly Once

  • 幂等性机制
  • 使用时,只需将enable.idempotence属性设置为true,kafka自动将acks属性设为-1,并将retries属性设为Integer.MAX_VALUE

13.Kafka消费者方式

consumer采用pull(拉)模式从broker中读取数据

  • push(推)模式很难适应消费速率不同的消费者,因为消息发送速率有broker决定的.
  • pull模式的不足之处,如果kafka没有数据,消费者可能会陷入循环中,一直返回空数据.

14.offset的维护

  Kafka 0.9版本之前,consumer默认将offset保存在Zookeeper中,从0.9版本开始,consumer默认将offset保存在Kafka一个内置的topic中,该topic为__consumer_offsets。


15.Kafka高速读写数据

  • 顺序写磁盘
  • 零复制计数

16.Zookeeper在Kafka中的作用

  Kafka集群中有一个broker会被选举为Controller,负责管理集群broker的上下线,所有topic的分区副本分配和leader选举等工作。
  Controller的管理工作都是依赖于Zookeeper的。


17.选举流程

在这里插入图片描述
在这里插入图片描述


18.KafkaProducerApi原理

在这里插入图片描述
Kafka的producer发送消息采用的是异步发送的方式.

  • main线程
  • Sender线程

线程共享变量 RecordAccumulator;

main线程将消息发送到RecordAccumulator,Sender线程不断从RecordAccumulator中拉去信息发送到Kafka broker.

相关参数:

  • batch.size:只有数据积累到batch.size之后,Sender才会发送数据
  • linger.ms:如果数据迟迟没有达到batch.size,sender等待linger.time之后就会发送数据

19.Producer API

需要用到的类:

  • KafkaProducer:创建一个生产者对象,用来发送数据
  • ProducerConfig:获取所需的一系列配置参数
  • ProducerRecord:每条数据都要封装成一个ProducerRecord对象
//异步发送 API

public class CustomProducer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者的应答机制,
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,1);
        //设置传输批次的大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        //设置缓冲区的大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        //设置k-v的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("first","message"+i));
        }
        producer.close();
    }
}


带回调函数的API:
  回调函数会在producer收到ack时调用,为异步调用,该方法有两个参数,分别是RecordMetadata和Exception,如果Exception为null,说明消息发送成功,如果不为空,说明发送失败;

//带回调函数的 API
// 异步
public class CustomProducer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者的应答机制,
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,1);
        //设置传输批次的大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        //设置缓冲区的大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        //设置k-v的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("first", "message" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if(e == null){
                        System.out.println("success->" + recordMetadata.offset());
                    }else {
                        e.printStackTrace();
                    }
                }
            });
        }
        producer.close();
    }
}

同步发送API:
  同步的意思就是,一条消息发送之后,会堵塞当前线程,直至返回ack

  由于send方法返回的是一个Future对象,根据Futrue对象的特点,我们也可以实现同步发送的效果,只需在调用Future对象的get方法即可;

public class CustomProducer {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者的应答机制,
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,1);
        //设置传输批次的大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        //设置缓冲区的大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        //设置k-v的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("first", "message" + i)).get();
        }
        producer.close();
    }
}


20.Consumer API

  Consumer消费数据时的可靠性是很容易保证的,因为数据在Kafka重视持久化的,故不用担心数据丢失问题.
  由于consumer在消费过程中可能会出现断电宕机等故障,consumer回复后,需要从故障钱的位置继续消费,所以consumer需要实时记录自己消费到哪个offset,以便故障回复后继续消费.
  所以offset的维护是Consumer消费数据是必须考虑的问题.

需要用到的类:

  • KafkaConsumer:需要创建一个消费者对象,用来消费对象
  • ConsumerConfig:获取所需的一系列系统配置参数
  • ConsumerRecord:每条数据都要封装成一个ConsumerRecord对象

自动提交offset的相关参数:
  enable.auto.commit:是否开启自动提交offset功能
  auto.commit.intervals.ms:自动提交offset 的时间间隔

//自动提交offset

public class CustomConsumer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"));
        while (true){
            //设置间隔时间,间隔一段时间进行一次拉取数据,获得ConsumerRecords对象
            ConsumerRecords<String, String> records = consumer.poll(100);
            //遍历records,进行消费
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
            }
        }
    }
}

手动提交offset 的两种方法 :commitSnync(同步提交) commitAsync(异步提交)

  • 相同点:都会把本次poll的一批数据最高的偏移量提交;
  • 不同点: commitSync阻塞当前线程,一直到提交成功,并且会自动失败重试
    commitAsync没有失败重试机制,故有可能提交失败.
//同步拉取

public class CustomConsumer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"));
        while (true){
            // 设置间隔时间,间隔一段时间进行一次拉取数据,获得ConsumerRecords对象
            ConsumerRecords<String, String> records = consumer.poll(100);
            // 遍历records,进行消费
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
            }
            // 同步提交,当前线程会阻塞直到offset提交成功
            consumer.commitSync();
        }
    }
}
//异步拉取

public class CustomConsumer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"));
        while (true){
            //设置间隔时间,间隔一段时间进行一次拉取数据,获得ConsumerRecords对象
            ConsumerRecords<String, String> records = consumer.poll(100);
            //遍历records,进行消费
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
            }
            //异步拉取
            consumer.commitAsync(new OffsetCommitCallback() {
                public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception e) {
                    if( e != null){
                        System.out.println("Commit failed for " + offsets);
                    }
                }
            });
        }
    }
}

21.数据漏消费和重复消费分析

  • 无论是同步提交还是异步提交,都有可能会造成数据的漏消费或者重复消费.
  • 先提交offset后消费的,有可能造成数据的楼消费; 而先消费后提交offset,有可能会造成数据重复消费.

22.自定义存储offset

  当有新的消费者加入消费者组,已有的消费者退出消费者组或者所订阅的主题的分区发生变化,就会触发到分区的重新分配,重新分配的过程叫做Rebalance.
  因此消费者要首先获取到自己被重新分配到的分区,并且定位到每个分区最近提交的offset 位置继续消费.
  要实现自定义存储offset,需要借助ConsumerRebalanceListener.

// 自定义存储offset

public class CustomConsumer {
    // 用于存储offset
    private static Map<TopicPartition,Long> currentOffset = new HashMap<TopicPartition, Long>();

    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        final KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"), new ConsumerRebalanceListener() {
            //该方法会在Rebalance之前调用
            public void onPartitionsRevoked(Collection<TopicPartition> collection) {
                commitOffset(currentOffset);
            }
            //该方法会在Rebalance之后调用
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                currentOffset.clear();
                for (TopicPartition partition : partitions) {
                    consumer.seek(partition,getOffset(partition)); //定位到最近提交的offset位置继续消费
                }
            }
        });
        while (true){
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
                currentOffset.put(new TopicPartition(record.topic(),record.partition()),record.offset())
            }
            commitOffset(currentOffset);
        }
    }
    // 获取某分区的最新offset
    private static long getOffset(TopicPartition partition) {
        return 0;
    }

    // 提交该消费者所有分区的offset
    private static void commitOffset(Map<TopicPartition, Long> currentOffset) {

    }

}


23.自定义拦截器

  用于实现clients端的定制化控制逻辑.
  对于producer而言,interceptor使得用户在消息发送前以及producer回调逻辑前有机会对消息做一些定制化需求.

  实现的接口是:org.apache.kafka.clients.producer.ProducerInterceptor

定义的方法:

  configure(configs):获取配置信息和初始化数据时调用

  onSend(ProducerRecord):该方法封装进KafkaProducer.send方法中,即它运行在用户主线程中。Producer确保在消息被序列化以及计算分区前调用该方法。用户可以在该方法中对消息做任何操作,但最好保证不要修改消息所属的topic和分区,否则会影响目标分区的计算。

  onAsknowledgement(RecordMetadata,Exception): 该方法会在消息从RecordAccumulator成功发送到Kafka Broker之后,或者在发送过程中失败时调用。并且通常都是在producer回调逻辑触发之前。onAcknowledgement运行在producer的IO线程中,因此不要在该方法中放入很重的逻辑,否则会拖慢producer的消息发送效率。

  close():关闭interceptor,主要用于执行一些资源清理工作
如前所述,interceptor可能被运行在多个线程中,因此在具体实现时用户需要自行确保线程安全。另外倘若指定了多个interceptor,则producer将按照指定顺序调用它们,并仅仅是捕获每个interceptor可能抛出的异常记录到错误日志中而非在向上传递。这在使用过程中要特别留意。


24.拦截器案例

  实现一个简单的双interceptor组成的拦截链。第一个interceptor会在消息发送前将时间戳信息加到消息value的最前部;第二个interceptor会在消息发送后更新成功发送消息数或失败发送消息数。

public class TimeStampPrependerInterceptor implements ProducerInterceptor<String, String> {
    @Override
    public void configure(Map<String, ?> configs) {

    }

    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        return new ProducerRecord(
                record.topic(), record.partition(), record.timestamp(), record.key(), System.currentTimeMillis() + "," + record.value().toString());
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {

    }

    @Override
    public void close() {
    }
}

public class CounterInterceptor implements ProducerInterceptor<String, String> {

    private int errorCounter = 0;
    private int successCounter = 0;

    @Override
    public void configure(Map<String, ?> configs) {
    }

    @Override
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> record) {
        return record;
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        if (exception == null) {
            successCounter++;
        } else {
            errorCounter++;
        }
    }

    @Override
    public void close() {
        // 保存结果
        System.out.println("Successful sent: " + successCounter);
        System.out.println("Failed sent: " + errorCounter);
    }
}

Properties props = new Properties();
props.put(...);
// 构建拦截链
List<String> interceptors = new ArrayList<>();
interceptors.add("huxi.test.producer.TimeStampPrependerInterceptor"); // interceptor 1
interceptors.add("huxi.test.producer.CounterInterceptor"); // interceptor 2
props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, interceptors);
...
 
String topic = "test-topic";
Producer<String, String> producer = new KafkaProducer<>(props);
for (int i = 0; i < 10; i++) {
    ProducerRecord<String, String> record = new ProducerRecord<>(topic, "message" + i);
    producer.send(record).get();
}
 
// 一定要关闭producer,这样才会调用interceptor的close方法
producer.close();


25.Flume对接Kafka

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

# source
a1.sources.r1.type = exec
a1.sources.r1.command = tail -F -c +0 /opt/module/datas/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


26.Kafka监控

1.Kafka Monitor
    https://github.com/linkedin/kafka-monitor/tree/0.11.x
2.Kafka Manager
    https://github.com/didi/kafka-manager

总结

提示:这里对文章进行总结:
本文分享了本菜鸟的Kafka学习笔记,内容有点多,查看时最好根据目录查看自己想要查询的部分。Kafka作为大数据组件中一个非常重要的消息队列,应该是每个大数据员工的必备技能。
本菜鸟QQ:599903582
笨鸟先飞,熟能生巧!
比心心~

已标记关键词 清除标记
【为什么还需要学习C++?】 你是否接触很多语言,但从来没有了解过编程语言的本质? 你是否想成为一名资深开发人员,想开发别人做不了的高性能程序? 你是否经常想要窥探大型企业级开发工程的思路,但苦于没有基础只能望洋兴叹?   那么C++就是你个人能力提升,职业之路进阶的不二之选。 【课程特色】 1.课程共19大章节,239课时内容,涵盖数据结构、函数、类、指针、标准库全部知识体系。 2.带你从知识与思想的层面从0构建C++知识框架,分析大型项目实践思路,为你打下坚实的基础。 3.李宁老师结合4大国外顶级C++著作的精华为大家推出的《征服C++11》课程。 【学完后我将达到什么水平?】 1.对C++的各个知识能够熟练配置、开发、部署; 2.吊打一切关于C++的笔试面试题; 3.面向物联网的“嵌入式”和面向大型化的“分布式”开发,掌握职业钥匙,把握行业先机。 【面向人群】 1.希望一站式快速入门的C++初学者; 2.希望快速学习 C++、掌握编程要义、修炼内功的开发者; 3.有志于挑战更高级的开发项目,成为资深开发的工程师。 【课程设计】 本课程包含3大模块 基础篇 本篇主要讲解c++的基础概念,包含数据类型、运算符等基本语法,数组、指针、字符串等基本词法,循环、函数、类等基本句法等。 进阶篇 本篇主要讲解编程中常用的一些技能,包含类的高级技术、类的继承、编译链接和命名空间等。 提升篇: 本篇可以帮助学员更加高效的进行c++开发,其中包含类型转换、文件操作、异常处理、代码重用等内容。
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页