canal+kafka+go处理Mysql数据库增量信息

注意：canal使用java写的，需要安装jdk环境

canal介绍安装

说明

• canal是阿里开源的监控数据库增量信息的框架，支持的数据库包括mysql.
• 主要原理是canal是模拟MySQL的从机(slave), 发送指令获取master的增量信息
• 主要用途是实现跨区域MySQL数据备份处理
• 需要配置MySQL的参数和具体的详细说明，参考canal官网https://github.com/alibaba/canal
• 本人安装的版本是v1.1.4 , 下载链接https://github.com/alibaba/canal/releases下载的文件是canal.deployer-1.1.4.tar.gz

安装说明

• 采用的是单节点的方式，集群可以参考官网。环境为centos7, 阿里云服务器

• 将下载好的压缩包解压到指定的目录中，会有4个文件夹
  image.png
• bin是执行的二进制文件，conf为配置文件，logs为日志文件

• 打开conf/example/instance.properties文件配置数据库和kafka信息
  image.png
  image.png
  image.png
• 注意：过滤表数据的配置 canal.instance.filter.regex 和 按照表名定义kafka主题的canal.instance.filter.regex配置是支持表达式的。例如：.*\..*是表示所有库的所有表，test\..*是test库的所有表，test.table1表示test库的table1表

• 配置canal信息：打开conf目录下的canal.properties文件
  image.png
  image.png
  image.png
• canal是支持连接池和kafka集群的，可以参考官网
• 进入到bin目录下，执行./startup.sh bin目录下生成canal.pid，查看端口有11110-11112说明启动成功，前提是先启动kafka
• 关闭canal是./stop.sh ,canal.pid文件将被删除

kafka安装

• 从官网下载压缩文件，我安装的版本是kafka_2.13-2.6.0.tgz
• 解压到指定的目录
• kafka是依赖zookeeper的，可以使用文件中已经配置好的zookeeper，也可以单独安装
• kafka的执行文件在bin目录下，提供一下几个命令

### 开启本地zookeeper指令(使用kafka已经配置好的)
./zookeeper-server-start.sh config/zookeeper.properties

### 开启kafka指令
./kafka-server-start.sh config/server.properties

### 查看指定topic信息, 例如查看topic为 example
./kafka-topics.sh --bootstrap-server 127.0.0.1:9092 --describe --topic example

### 监听指定topic消息客户端
./kafka-console-consumer.sh --bootstrap-server 127.0.0.1:9092 --from-beginning --topic example

### 发送消息到指定topic客户端
./kafka-console-producer.sh --topic=test --broker-list 127.0.0.1:9092

### 删除指定topic
./kafka-topics.sh --bootstrap-server 127.0.0.1:9092  --delete --topic example

• 说明9092是kafka的端口，2181是zookeeper的端口。可以通过指令 netstat -tunlp查看

• kafka遇到的坑：本人的是在阿里云上不是的单节点kafka，如果在其他的地方通过公网去访问kafka是不行的，即便开启了端口映射，也不可以。参照网上的做法是：为该机器的ip申请一个域名，通过配置文件配置域名就可以在其他的通过域名加9092端口就可以访问了，配置文件说明，打开config/server.properties
  image.png
• 如果要关闭kafka必须先关闭kafka服务再关闭zookeeper服务，关闭指令再bin目录下

操作的go代码

consumer.go

package consumer

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

type ConsumeTopic struct {
    //一个消费者组里包含几个消费者
    ConsumeNum int
    //消费者组监听的主题
    Topics []string
    //回调的Handler, 需要调用者自己实现
    Callback sarama.ConsumerGroupHandler
}

type consumer struct {
    //kafka地址集合: 例如[]string{域名:9092, ip:9093, ...}
    //addressSet []string
    //消费者组绑定主题: key为group主题id
    consumerGroupTopic map[string]ConsumeTopic
    //consumer配置
    consumerConfig *sarama.Config
    client         sarama.Client

    consumerGroup []sarama.ConsumerGroup
}

//创建消费者对象
//addressSet: kafka地址集合
//consumerGroupTopic: 消费者组信息
//consumerConfig: 消费者配置信息，如果为空就采用默认的配置
func CreateNewConsumer(addressSet []string, consumerGroupTopic map[string]ConsumeTopic, consumerConfig *sarama.Config) *consumer {
    consumer := consumer{
        //addressSet:         addressSet,
        consumerGroupTopic: consumerGroupTopic,
        consumerConfig:     consumerConfig,
    }
    //启用默认配置
    if consumer.consumerConfig == nil {
        consumer.consumerConfig = sarama.NewConfig()
        consumer.consumerConfig.Consumer.Return.Errors = false
        consumer.consumerConfig.Version = sarama.V2_6_0_0
        consumer.consumerConfig.Consumer.Offsets.Initial = sarama.OffsetOldest
    }

    client, err := sarama.NewClient(addressSet, consumer.consumerConfig)
    if err != nil {
        panic(err)
    }
    consumer.client = client

    //开始
    consumer.init()
    return &consumer
}

//初始化
func (c *consumer) init() {
    for groupId, v := range c.consumerGroupTopic {
        consumerGroup, err := sarama.NewConsumerGroupFromClient(groupId, c.client)
        if err != nil {
            panic(err)
        }

        for i := 0; i < v.ConsumeNum; i++ {
            go c.consume(&consumerGroup, c.consumerGroupTopic[groupId].Topics, c.consumerGroupTopic[groupId].Callback)
        }

        c.consumerGroup = append(c.consumerGroup, consumerGroup)
    }
}

func (c *consumer) consume(group *sarama.ConsumerGroup, topics []string, consumerGroupHandler sarama.ConsumerGroupHandler) {
    ctx := context.Background()
    for {
        err := (*group).Consume(ctx, topics, consumerGroupHandler)
        if err != nil {
            panic(err)
        }
    }
}

//关闭
func (c *consumer) Close() {
    for _, v := range c.consumerGroup {
        v.Close()
    }
    c.client.Close()
}

consumer_test.go

package consumer

import (
    "fmt"
    "github.com/Shopify/sarama"
    "os"
    "os/signal"
    "testing"
)

type consumerGroupHandler struct {
    name string
}

func (h consumerGroupHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
func (h consumerGroupHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
func (h consumerGroupHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
    claim sarama.ConsumerGroupClaim) error {
    for msg := range claim.Messages() {
        fmt.Printf("%s Message topic:%q partition:%d offset:%d  value:%s\n",
            h.name, msg.Topic, msg.Partition, msg.Offset, string(msg.Value))
        // 手动确认消息
        sess.MarkMessage(msg, "")
    }
    return nil
}

func TestCreateNewConsumer(t *testing.T) {
    cgt := map[string]ConsumeTopic{}
    cgt["id01"] = ConsumeTopic{
        ConsumeNum: 2,
        Topics:     []string{"read_book.wode"},
        Callback:   consumerGroupHandler{},
    }
    cClient := CreateNewConsumer([]string{"你的域名.com:9092"}, cgt, nil)

    signals := make(chan os.Signal, 1)
    signal.Notify(signals, os.Interrupt)
    select {
    case <-signals:
    }
    cClient.Close()
}