極速精簡 Go 版 Logstash

Kevin Wan 發表於 2021-04-06
Go

前言

今天來介紹 go-zero 生態的另一個元件 go-stash。這是一個 logstash 的 Go 語言替代版,我們用 go-stash 相比原先的 logstash 節省了2/3的伺服器資源。如果你在用 logstash,不妨試試,也可以看看基於 go-zero 實現這樣的工具是多麼的容易,這個工具作者僅用了兩天時間。

整體架構

先從它的配置中,我們來看看設計架構。

Clusters:
  - Input:
      Kafka:
        # Kafka 配置 --> 聯動 go-queue
    Filters:
    	# filter action
      - Action: drop            
      - Action: remove_field
      - Action: transfer      
    Output:
      ElasticSearch:
        # es 配置 {host, index}

看配置名:kafka 是資料輸出端,es 是資料輸入端,filter 抽象了資料處理過程。

對,整個 go-stash 就是如 config 配置中顯示的,所見即所得。

image.png

啟動

stash.go 的啟動流程大致分為幾個部分。因為可以配置多個 cluster,那從一個 cluster 分析:

  1. 建立與 es 的連線【傳入 es 配置】
  2. 構建 filter processorses 前置處理器,做資料過濾以及處理,可以設定多個】
  3. 完善對 es 中 索引配置,啟動 handle ,同時將 filter 加入handle【處理輸入輸出】
  4. 連線下游的 kafka,將上面建立的 handle 傳入,完成 kafkaes 之間的資料消費和資料寫入

MessageHandler

在上面架構圖中,中間的 filter 只是從 config 中看到,其實更詳細是 MessageHandler 的一部分,做資料過濾和轉換,下面來說說這塊。

以下程式碼:https://github.com/tal-tech/go-stash/tree/master/stash/handler/handler.go

type MessageHandler struct {
	writer  *es.Writer
	indexer *es.Index
	filters []filter.FilterFunc
}

這個就對應上面說的,filter 只是其中一部分,在結構上 MessageHandler 是對接下游 es ,但是沒有看到對 kafka 的操作。

別急,從介面設計上 MessageHandler 實現了 go-queueConsumeHandler 介面。

這裡,上下游就串聯了:

  1. MessageHandler 接管了 es 的操作,負責資料處理到資料寫入
  2. 對上實現了 kafkaConsume 操作。這樣在消費過程中執行 handler 的操作,從而寫入 es

實際上,Consume() 也是這麼處理的:

func (mh *MessageHandler) Consume(_, val string) error {
	var m map[string]interface{}
  // 反序列化從 kafka 中的訊息
	if err := jsoniter.Unmarshal([]byte(val), &m); err != nil {
		return err
	}
	// es 寫入index配置
	index := mh.indexer.GetIndex(m)
  // filter 鏈式處理【因為沒有泛型,整個處理都是 `map進map出`】
	for _, proc := range mh.filters {
		if m = proc(m); m == nil {
			return nil
		}
	}
	bs, err := jsoniter.Marshal(m)
	if err != nil {
		return err
	}
	// es 寫入
	return mh.writer.Write(index, string(bs))
}

資料流

說完了資料處理,以及上下游的連線點。但是資料要從 kafka -> es ,資料流出這個動作從 kafka 角度看,應該是由開發者主動 pull data from kafka

那麼資料流是怎麼動起來?我們回到主程式 https://github.com/tal-tech/go-stash/blob/master/stash/stash.go

其實 啟動 整個流程中,其實就是一個組合模式:

func main() {
	// 解析命令列引數,啟動優雅退出
	...
  // service 組合模式
	group := service.NewServiceGroup()
	defer group.Stop()

	for _, processor := range c.Clusters {
		// 連線es
    ...
		// filter processors 構建
    ...
    // 準備es的寫入操作 {寫入的index, 寫入器writer}
		handle := handler.NewHandler(writer, indexer)
		handle.AddFilters(filters...)
		handle.AddFilters(filter.AddUriFieldFilter("url", "uri"))
    // 按照配置啟動kafka,並將消費操作傳入,同時加入組合器
		for _, k := range toKqConf(processor.Input.Kafka) {
			group.Add(kq.MustNewQueue(k, handle))
		}
	}
	// 啟動這個組合器
	group.Start()
}

整個資料流,就和這個 group 組合器有關了。

group.Start()
	|- group.doStart()
		|- [service.Start() for service in group.services]

那麼說明加入 groupservice 都是實現 Start()。也就是說 kafka 端的啟動邏輯在 Start()

func (q *kafkaQueue) Start() {
	q.startConsumers()
	q.startProducers()

	q.producerRoutines.Wait()
	close(q.channel)
	q.consumerRoutines.Wait()
}
  1. 啟動 kafka 消費程式
  2. 啟動 kafka 消費拉取端【可能會被名字迷惑,實際上是從 kafka 拉取訊息到 q.channel
  3. 消費程式終止,收尾工作

而我們傳入 kafka 中的 handler,上文說過其實是 Consume,而這個方法就是在 q.startConsumers() 中執行的:

q.startConsumers()
	|- [q.consumeOne(key, value) for msg in q.channel]
		|- q.handler.Consume(key, value)

這樣整個資料流就徹底串起來了:

image.png

總結

作為 go-stash 第一篇文章,本篇從架構和設計上整體介紹 go-stash ,有關效能和為什麼我們要開發一個這樣的元件,我們下篇文章逐漸揭曉。

https://github.com/tal-tech/go-stash

關於 go-zero 更多的設計和實現文章,可以持續關注我們。

https://github.com/tal-tech/go-zero

歡迎使用 go-zero 並 star 支援我們!

微信交流群

關注『微服務實踐』公眾號並回復 進群 獲取社群群二維碼。