Kafka

Kafka

kafka⾼吞吐量的分布式队列（Linkin开发，apache顶级开源项⽬）
kafka是一个分布式数据流平台，可以运行在单台服务器上，也可以在多台服务器上部署形成集群。他提供了发布和订阅功能，使用者可以发送数据到kafka中，也可以从kafka中读取数据（以便进行后续的处理）kafka具有高吞吐，低延迟，高容错的特点

架构

• Producer：Producer即⽣生产者，消息的产⽣生者，是消息的⼊入⼝口。
• kafka cluster：kafka集群，⼀一台或多台服务器器组成
  1.Broker：Broker是指部署了了Kafka实例例的服务器器节点。每个服务器器上有⼀一个或多个kafka的实
  例例，我们姑且认为每个broker对应⼀一台服务器器。每个kafka集群内的broker都有⼀一个不不重复的
  编号，如图中的broker-0、broker-1等……
  2.Topic：消息的主题，可以理理解为消息的分类，kafka的数据就保存在topic。在每个broker上
  都可以创建多个topic。实际应⽤用中通常是⼀一个业务线建⼀一个topic。
  Partition：Topic的分区，每个topic可以有多个分区，分区的作⽤用是做负载，提⾼高kafka的吞
  吐量量。同⼀一个topic在不不同的分区的数据是不不重复的，partition的表现形式就是⼀一个⼀一个的⽂文
  件夹！
  3.Replication:每⼀一个分区都有多个副本，副本的作⽤用是做备胎。当主分区（Leader）故障的
  时候会选择⼀一个备胎（Follower）上位，成为Leader。在kafka中默认副本的最⼤大数量量是10
  个，且副本的数量量不不能⼤大于Broker的数量量，follower和leader绝对是在不不同的机器器，同⼀一机
  器器对同⼀一个分区也只可能存放⼀一个副本（包括⾃自⼰己）。
  4.Consumer：消费者，即消息的消费⽅方，是消息的出⼝口。
• Consumer Group：我们可以将多个消费组组成⼀一个消费者组，在kafka的设计中同⼀一个分
  区的数据只能被消费者组中的某⼀一个消费者消费。同⼀一个消费者组的消费者可以消费同⼀一个
  topic的不不同分区的数据，这也是为了了提⾼高kafka的吞吐量量！

工作流程

1. 生产者从Kafka集群获取分区leader信息
2. 生产者将消息发送给leader
3. leader将消息写⼊入本地磁盘
4. follower从leader拉取消息数据
5. follower将消息写⼊入本地磁盘后向leader发送ACK
6. leader收到所有的follower的ACK之后向⽣生产者发送ACK

一.两个负载：
一个是Partition 分区，即接收负载，提高kafka的吞吐量。将topic数据放到不同的Partiton中，一个Broker的同一个topic下的 不同Partition的数据是不可以重复的。Partition的表现形式是一个一个的文件夹。

​ 一个是Consumer Group，即消费负载。将多个消费者组成一个消费组。同一个Partition 分区的数据只能被同一个消费组中的某个消费者消费。即同一个消费组中的消费者可以消费同一个topic不同分区的数据，也是为了提高kafka的吞吐量

​ 二.Replication 备胎/副本： 每个分区都有多个副本，副本的作用是做备胎。当一个Leader挂了，会选择一个备胎（Follower）上位做Leader。follower跟Leader绝对在不同的机器上，同一个机器对同一分区也只能存放一个副本。 Broker:部署了kafka实例的服务器节点，多个Broker做备份

​ 三.使用场景：

​ 消息队列（MQ）、追踪网站活动：（Kafka最出就是被设计用来进行网站活动（比如PV、 UV、搜索记录等）的追踪。可以将不不同的活动放⼊入不不同的主题，供后续的实时计算、实时监控等程序使用，也可以将数据导入到数据仓库中进行后续的离线处理理和生成报表等。） 、Metrics(传输监控数据)、日志聚合

四.启动kafka服务

1.启动Zookpper: 在zookeeper目录执行 bin\zkServer.cmd

2.启动kafka服务，执行：bin\windows\kafka-server-start.bat config\server.properties（前提，先启动zookeeper服务）

cmd命令开启kafka消费者：

执行：bin\windows\kafka-console-consumer.bat --bootstrap-server 127.0.0.1:9092 --topic shopping --from-beginning

五.go语言操作kafka

kafka生产者：（启用go mod ,因为sarama 使用的是v1.19的版本，需要在go mod里面指定版本号）

1.创建gomod：go mod init

2.加载引用包：go mod tidy -v

注：给生成文件重命名： go build -o rename.exe (rename为新的名字)

//基于sarama第三方库开发的 kafka client,往kafka里面发送消息

import (
	"fmt"
	"github.com/Shopify/sarama"
)

func main() {
	//1.生产者配置
	config := sarama.NewConfig()
	config.Producer.RequiredAcks = sarama.WaitForAll          //Ack 设置生产者发送完数据是否需要leader和follower都确认
	config.Producer.Partitioner = sarama.NewRandomPartitioner //partition 新选择一个分区partition
	config.Producer.Return.Successes = true                   //确认 成功交付的消息将在success channel返回

	//2.连接kafka
	client, err := sarama.NewSyncProducer([]string{"192.168.42.133:9092"}, config)
	if err != nil {
		fmt.Println("producer closed,err:", err)
		return
	}
	defer client.Close()

	//3.封装消息
	msg := &sarama.ProducerMessage{}
	msg.Topic = "shopping"
	msg.Value = sarama.StringEncoder("this is a test log")

	//4.发送消息
	pid, offset, err := client.SendMessage(msg)
	if err != nil {
		fmt.Println("send msg failed,err:", err)
		return
	}
	fmt.Printf("分区pid:%v 偏移offset:%v\n", pid, offset)
}

tailf包：实时获取某个文件信息，实时输出

//tailf包一直接受文件中的消息

import (
	"fmt"
	"github.com/hpcloud/tail"
	"time"
)

func main() {
	filename := `./xx.log`
	config := tail.Config{
		ReOpen:   true,
		Follow:   true,
		Location: &tail.SeekInfo{Offset: 0, Whence: 2}, MustExist: false,
		Poll: true,
	}

	//1. 打开文件开始读取数据
	tails, err := tail.TailFile(filename, config)
	if err != nil {
		fmt.Printf("tail %s failed,err:%v\n", filename, err)
		return
	}

	//2.读取数据
	var (
		msg *tail.Line
		ok  bool
	)
	for {
		msg, ok = <-tails.Lines //chan tail.Line
		if !ok {
			fmt.Printf("tail file close reopen,filename:%s\n", tails.Filename)
			time.Sleep(time.Second) //读取出错，等一秒
			continue
		}
		fmt.Println("msg:", msg.Text)
	}
}

kafka消费

package main

import (
	"fmt"
	"github.com/Shopify/sarama"
	"sync"
)

// kafka consumer(消费者)

func main() {
	// 创建新的消费者
	consumer, err := sarama.NewConsumer([]string{"192.168.42.133:9092"}, nil)
	if err != nil {
		fmt.Printf("fail to start consumer, err:%v\n", err)
		return
	}
	// 拿到指定topic下面的所有分区列表
	partitionList, err := consumer.Partitions("web_log") // 根据topic取到所有的分区
	if err != nil {
		fmt.Printf("fail to get list of partition:err%v\n", err)
		return
	}
	fmt.Println(partitionList)
	var wg sync.WaitGroup
	for partition := range partitionList { // 遍历所有的分区
		// 针对每个分区创建一个对应的分区消费者
		pc, err := consumer.ConsumePartition("web_log", int32(partition), sarama.OffsetNewest)
		if err != nil {
			fmt.Printf("failed to start consumer for partition %d,err:%v\n",
				partition, err)
			return
		}
		defer pc.AsyncClose()
		// 异步从每个分区消费信息
		wg.Add(1)
		go func(sarama.PartitionConsumer) {
			for msg := range pc.Messages() {
				fmt.Printf("Partition:%d Offset:%d Key:%s Value:%s",
					msg.Partition, msg.Offset, msg.Key, msg.Value)
			}
		}(pc)
	}
	wg.Wait()
}

Zookeeper

是一个分布式的，开放源码的分布式应用程序协调服务，是集群的管理者，监视着集群中各个节点的状态，根据节点提交的反馈进行下一步合理操作。最终将简单易用的接口和性能高效、功能稳定的系统提供给用户。

启动Zookpper: 在zookeeper目录执行 bin\zkServer.cmd