Golang实战之海量日志收集系统（五）根据etcd配置项创建多个tailTask

最新推荐文章于 2024-05-07 08:29:03 发布
最新推荐文章于 2024-05-07 08:29:03 发布
阅读量632 收藏 1
点赞数 1
分类专栏： Golang 文章标签： go golang kafka etcd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43442524/article/details/105054482
版权

在这里插入图片描述

Hello，我是普通Gopher，00后男孩，极致的共享主义者，想要成为一个终身学习者。专注于做最通俗易懂的计算机基础知识类公众号。每天推送Golang技术干货，内容起于K8S而不止于K8S，涉及Docker、微服务、DevOps、数据库、虚拟化等云计算内容及SRE经验总结
=======================
初次见面，我为你准备了100G学习大礼包：
1、《百余本最新计算机电子图书》
2、《30G Golang学习视频》
3、《20G Java学习视频》
4、《90G Liunx高级学习视频》
5、《10G 算法（含蓝桥杯真题）学习视频》
6、《英语四级，周杰伦歌曲免费送！》
路过麻烦动动小手，点个关注，持续更新技术文章与资料！

目录:

GitHub项目地址：https://github.com/PlutoaCharon/Golang_logCollect⭐

Golang实战之海量日志收集系统（一）项目背景介绍

Golang实战之海量日志收集系统（二）收集应用程序日志到Kafka中

Golang实战之海量日志收集系统（三）简单版本logAgent的实现

Golang实战之海量日志收集系统（四）etcd介绍与使用etcd获取配置信息

Golang实战之海量日志收集系统（五）根据etcd配置项创建多个tailTask

Golang实战之海量日志收集系统（六）监视etcd配置项的变更

Golang实战之海量日志收集系统（七）logTransfer之从kafka中获取日志信息

Golang实战之海量日志收集系统（八）logTransfer之将日志入库到Elasticsearch并通过Kibana进行展示

通过上一篇从etcd中获取配置信息, 现在要拿着这些配置项进行日志收集

根据etcd的配置项创建多个tailtask

项目结构:

.

│  go.mod
│  go.sum
│
│
├─conf
│      logagent.conf
│
├─kafka
│      kafka.go
│
├─logs
│      my.log
│
├─main
│      config.go
│      etcd.go
│      ip.go
│      log.go
│      main.go
│      server.go
│
├─tailf
│      tail.go
│
└─tools
    └─SetConf
            main.go

新增tools包, 包含SetConf里的main.go将设置的配置信息导入到etcd中

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"logagent/tailf"
	"time"
)

// 定义etcd的前缀key
const (
	EtcdKey = "/backend/logagent/config/192.168.0.11"
)

func SetLogConfToEtcd() {
	cli, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379", "localhost:22379", "localhost:32379"},
		DialTimeout: 5 * time.Second,
	})
	if err != nil {
		fmt.Println("connect failed, err:", err)
		return
	}

	fmt.Println("connect succ")
	defer cli.Close()

	var logConfArr []tailf.CollectConf
	logConfArr = append(
		logConfArr,
		tailf.CollectConf{
			LogPath: "E:/nginx/logs/access.log",
			Topic:   "nginx_log",
		},
	)
	logConfArr = append(
		logConfArr,
		tailf.CollectConf{
			LogPath: "E:/nginx/logs/error.log",
			Topic:   "nginx_log_err",
		},
	)

	// Json打包
	data, err := json.Marshal(logConfArr)
	if err != nil {
		fmt.Println("json failed, ", err)
		return
	}

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	_, err = cli.Put(ctx, EtcdKey, string(data))
	cancel()
	if err != nil {
		fmt.Println("put failed, err:", err)
		return
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second)
	resp, err := cli.Get(ctx, EtcdKey)
	cancel()
	if err != nil {
		fmt.Println("get failed, err:", err)
		return
	}
	for _, ev := range resp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}
}

func main() {
	SetLogConfToEtcd()
}

直接运行文件

connect succ
/backend/logagent/config/192.168.0.11 : [{"path":"E:/nginx/logs/access.log","topic":"nginx_log"},{"path":"E:/nginx/logs/error.log","topic":"nginx_log_err"}]

成功将配置信息导入到etcd中, 下一步需要根据etcd中的配置项, 创建多个tailtask
我们想要实现的是

E:/nginx/logs/access.log 日志文件发送到kafka的nginx_log中
E:/nginx/logs/error.log 日志文件发送到kafka的nginx_log_err中

main包中新建etcd.go文件

用于初始化连接etcd与从etcd中取出配置信息

因为存入etcd时传入的是json格式，所以取出使用时需要反序列化json.Unmarshal(v.Value, &collectConf)

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego/logs"
	"github.com/coreos/etcd/clientv3"
	"logagent/tailf"
	"strings"
	"time"
)

type EtcdClient struct {
	client *clientv3.Client
}

var (
	etcdClient *EtcdClient
)

func initEtcd(addr string, key string) (collectConf []tailf.CollectConf, err error) {
	// 初始化连接etcd
	cli, err := clientv3.New(clientv3.Config{
		//Endpoints:   []string{"localhost:2379", "localhost:22379", "localhost:32379"},
		Endpoints:   []string{addr},
		DialTimeout: 5 * time.Second,
	})
	if err != nil {
		logs.Error("连接etcd失败:", err)
		return
	}

	etcdClient = &EtcdClient{
		client: cli,
	}

	// 如果Key不是以"/"结尾, 则自动加上"/"
	if strings.HasSuffix(key, "/") == false {
		key = key + "/"
	}

	for _, ip := range localIPArray {
		etcdKey := fmt.Sprintf("%s%s", key, ip)
		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
		resp, err := cli.Get(ctx, etcdKey)
		if err != nil {
			logs.Error("etcd get请求失败:", err)
			continue
		}
		cancel()
		logs.Debug("resp from etcd:%v", resp.Kvs)
		for _, v := range resp.Kvs {
			if string(v.Key) == etcdKey {
				// 将从etcd中取出来的json格式反序列化为结构体
				err = json.Unmarshal(v.Value, &collectConf)
				if err != nil {
					logs.Error("反序列化失败:", err)
					continue
				}
				logs.Debug("日志设置为%v", collectConf)
			}
		}
	}

	logs.Debug("连接etcd成功")
	return
}

修改logagent.conf配置文件

[logs]
log_level = debug
log_path = E:\\Go\\logagent\\logs\\my.log

[collect]
log_path = E:\\Go\\logagent\\logs\\my.log
topic = nginx_log
chan_size = 100

[kafka]
server_addr = 0.0.0.0:9092

[etcd]
addr = 0.0.0.0:2379
configKey= /backend/logagent/config/

main包中新建ip.go文件

使用net包取出本机所有的网卡ip去连接etcd

考虑到以后添加新服务器时不需要手动添加ip，这里将ip信息全部存入localIPArray数组中

package main

import (
	"fmt"
	"net"
)

var (
	localIPArray []string
)

func init() {
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		panic(fmt.Sprintf("获取网卡ip失败, %v", err))
	}
	for _, addr := range addrs {
		if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
			if ipnet.IP.To4() != nil {
				localIPArray = append(localIPArray, ipnet.IP.String())
			}
		}
	}

	fmt.Println(localIPArray)
}

config.go加入etcd配置

	// etcd
	logConfig.etcdAddr = conf.String("etcd::addr")
	if len(logConfig.etcdAddr) == 0 {
		err = fmt.Errorf("初识化etcd addr失败")
		return
	}

	logConfig.etcdKey = conf.String("etcd::configKey")
	if len(logConfig.etcdKey) == 0 {
		err = fmt.Errorf("初识化etcd configKey失败")
		return
	}


// 日志配置
type Config struct {
	logLevel string
	logPath  string

	chanSize    int
	KafkaAddr   string
	collectConf []tailf.CollectConf

	etcdAddr string
	etcdKey  string
}

tail.go修改序列化

type CollectConf struct {
	LogPath string `json:"logpath"`
	Topic   string `json:"topic"`
}

main.go函数

将initEtcd初始化etcd函数放到InitTail函数之前, 使etcd中的配置项与tailf连接起来

package main

import (
	"fmt"
	"github.com/astaxie/beego/logs"
	"logagent/kafka"
	"logagent/tailf"
)

func main() {

	fmt.Println("开始")
	// 读取初始化配置文件
	filename := "E:\\Go\\logagent\\conf\\logagent.conf"
	err := loadInitConf("ini", filename)
	if err != nil {
		fmt.Printf("导入配置文件错误:%v\n", err)
		panic("导入配置文件错误")
		return
	}

	// 初始化日志信息
	err = initLogger()
	if err != nil {
		fmt.Printf("导入日志文件错误:%v\n", err)
		panic("导入日志文件错误")
		return
	}
	// 输出成功信息
	logs.Debug("导入日志成功%v", logConfig)

	// 初识化etcd
	collectConf, err := initEtcd(logConfig.etcdAddr, logConfig.etcdKey)
	if err != nil {
		logs.Error("初始化etcd失败",err)
	}
	logs.Debug("初始化etcd成功!")

	// 初始化tailf
	err = tailf.InitTail(collectConf, logConfig.chanSize)
	if err != nil {
		logs.Error("初始化tailf失败:", err)
		return
	}
	logs.Debug("初始化tailf成功!")

	// 初始化Kafka
	err = kafka.InitKafka(logConfig.KafkaAddr)
	if err != nil {
		logs.Error("初识化Kafka producer失败:", err)
		return
	}
	logs.Debug("初始化Kafka成功!")

	// 运行
	err = serverRun()
	if err != nil {
		logs.Error("serverRun failed:", err)
	}
	logs.Info("程序退出")
}

运行， 成功将etcd中的配置项经过tailf得到配置， 创建了多个tailtask

[169.254.109.181 169.254.30.148 192.168.106.1 192.168.0.1 192.168.0.11 169.254.153.68]
开始
{E:/nginx/logs/access.log nginx_log}
{E:/nginx/logs/error.log nginx_log_err}
2020/03/23 18:14:44 Waiting for E:/nginx/logs/access.log to appear...
2020/03/23 18:14:44 Waiting for E:/nginx/logs/error.log to appear...
普通Gopher
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang实战之truncate日志文件详解
09-20
主要给大家介绍了关于golang实战之truncate日志文件的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Go实现LogCollect：海量日志收集系统【上篇——LogAgent实现】
weixin_45565886的博客
09-01 1628
Go实现LogAgent：海量日志收集系统【上篇】
golang入门项目—日志收集
qq_43716830的博客
04-18 3503
传统ELK架构的日志收集： 存在的问题：Logstash耗资源较大，运行占用CPU和内存高。另外没有消息队列缓存，存在数据丢失隐患。适用于小规模的集群使用。 第二种架构： 位于各个节点上的Log Agent先将数据/日志传递给Kafka，并将队列中消息或数据交由Log Transfer，传递给Elasticsearch存储。最后由Kibana将日志和数据呈现给用户。因为引入了Kafka，数据会先被存储下来，所以即使Logstash server因故障停止运行，数据也不会丢失。这种架构适合于较大集群使用
Golang日志实战教程：掌握log与syslog库的高效使用
最新发布
walkskyer的博客
05-07 1659
在现代软件开发中，日志记录是一个不可或缺的功能，它帮助开发者跟踪应用程序的运行状态、监控程序行为、分析问题原因以及进行系统安全审核。在 Go 语言中，标准库提供了基础但功能强大的日志处理机制，尤其是log和syslog两个库，它们分别应对应用层面的日志需求和系统级的日志管理。本文将详细介绍如何在 Go 语言中使用这两个库，从基本的日志记录到复杂的日志管理，再到实战应用，旨在为中高级 Golang 开发者提供一个全面的学习和参考手册。
Go实现LogCollect：海量日志收集系统【下篇——开发LogTransfer】
weixin_45565886的博客
09-03 724
Go实现LogCollect：海量日志收集系统【下篇——开发LogTransfer】
探索Golang日志收集利器: GitCode上的`Golang_logCollect`
gitblog_00046的博客
04-23 304
探索Golang日志收集利器: GitCode上的Golang_logCollect 项目地址:https://gitcode.com/PlutoaCharon/Golang_logCollect 在这个数字化的时代，日志监控与收集对于任何应用系统来说都是至关重要的。它们是诊断问题、优化性能和保证服务稳定的关键工具。今天，我们将深入了解一下GitCode上由PlutoaCharon开源的项目——G...
Golang日志收集项目（采用taillog收集+etcd注册集群+kafka作为开源流处理平台+ES）
03-24
在构建一个基于Golang的日志收集系统时，我们通常会关注如何高效地处理大量日志数据，实现集群的动态扩展，并提供实时分析能力。在这个项目中，采用了多种技术组件来实现这一目标。以下是对这些技术及其应用的详细...
首次关于Golang高级爬虫实战课程+Golang语言实战应用之Beego轻博客开发教学
04-11
非常难得的关于Golang开发的高级实战课程，之前已经发布了非常多的Go语言基础学习教程，本次的课程是关于实战应用篇的技术教学。课程内容分为两个大的部分，第一部分就是非常重要的第一次关于GO语言的爬虫开发实战...
golang日志框架之logrus的使用
09-18
在Go语言中，日志处理是非常关键的部分，因为它有助于追踪程序运行时的问题和调试。...开发者可以根据项目需求，利用`logrus`的各种特性，构建高效、灵活的日志系统，以帮助诊断问题、优化性能并提高代码的可维护性。
Golang 日志接口应用实战源码
02-27
本文将深入探讨“Golang日志接口应用实战源码”所涉及的知识点，包括日志接口设计、日志级别、自定义日志处理器以及如何在实际项目中应用。 首先，`logger`目录很可能包含了日志处理的核心代码，可能包括一个实现了...
Go-LogVoyage-GoLang编写的功能全面的日志saas
08-14
LogVoyage - GoLang编写的功能全面的日志saas
Go-Filebeat是一个开源文件收集器主要用于获取日志文件并将其提供给logstash
08-14
Filebeat是一个开源文件收集器，主要用于获取日志文件并将其提供给logstash
logcollection:golang写的日志收集工具
05-06
logcollection golang写的日志收集工具 后台拖延中
golang日志服务器_Go实现海量日志收集系统(四)
weixin_39869733的博客
12-20 187
到这一步，我的收集系统就已经完成很大一部分工作，我们重新看一下我们之前画的图：我们已经完成前面的部分，剩下是要完成后半部分，将kafka中的数据扔到ElasticSearch，并且最终通过kibana展现出来ElasticSearch但是其实这里是需要配置一些东西的，要不然直接启动是会悲剧的，在网上找了一个地址，如果出现类似的错误直接处理就行，我自己已经验证了：https://blog.csdn....
Golang中记录日志详解
dennis的博客
01-18 1695
这三个包通常被一起使用是为了实现日志文件的轮转（log rotation）功能。这是一个用于文件日志轮转的 Go 语言包。它允许你创建按时间轮转的日志文件，确保日志文件不会无限制地增长，而是会按照一定的规则进行切割，例如按天、按小时等。这是 Logrus（一个 Go 语言的日志库）的一个钩子（hook）。Logrus 是一个功能强大的日志库，而 lfshook 允许你将 Logrus 的日志输出写入到文件，并且可以结合这个包，实现日志文件的定期轮转。
golang练手项目日志收集项目（一）
m0_56869626的博客
08-06 773
golang练手项目日志收集项目（一）
go实战之日志收集1
weixin_42324313的博客
12-16 1543
日志收集 一、项目背景 每个业务系统都有日志，当系统出现问题时，需要通过日志信息定位和解决问题。当系统机器规模很小时，登陆到服务器上查看即可满足，当系统机器规模很大时，登陆到机器上查看几乎不可能（分布式系统，一个系统部署在十几台机器上） 二、解决方案 把机器上的日志实时收集，存储到一个中心系统。再对这些日志建立索引，通过搜索可快速找到对应的日志，通过提供一个界面友好的web页面实现日志检索和展示。 三、面临问题 实时日志量非常大，每天处理几十亿条。日志准实时收集，延迟控制在分钟级别，能够支持水平扩展。 四、
go日志收集系统项目简介
一越王超的博客
04-26 2936
本节内容以go语言设计一个简易的日志收集系统，并且完成日志的客户端开发。 项目背景 每个系统都有日志，当系统出现问题的时候需要通过日志解决问题。 当系统机器比较少时，登录服务器即可查看日志。但当机器规模较大时，登录机器看就不太现实，这个时候就需要日志收集系统。 ...
logrus 输出多个文件_Golang-logrus简单的日志收集系统(替代ELKB)
05-25
在使用 logrus 输出日志的过程中，我们可以通过 Hook 的方式将日志同时输出到多个文件中，下面是示例代码： ```go package main import ( "os" log "github.com/sirupsen/logrus" ) func main() { // 创建一个新的日志记录器 logger := log.New() // 创建第一个日志文件 file1, err := os.OpenFile("log1.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) if err == nil { logger.SetOutput(file1) } else { logger.Info("Failed to log to file, using default stderr") } // 创建第二个日志文件 file2, err := os.OpenFile("log2.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) if err == nil { logger.AddHook(&logrusWriter{file2}) } else { logger.Info("Failed to log to file, using default stderr") } // 输出日志 logger.Info("Hello world!") } // logrusWriter 将日志输出到指定的 io.Writer type logrusWriter struct { writer io.Writer } func (writer *logrusWriter) Fire(entry *log.Entry) error { if _, err := writer.writer.Write([]byte(entry.Message)); err != nil { return err } return nil } func (writer *logrusWriter) Levels() []log.Level { return []log.Level{ log.PanicLevel, log.FatalLevel, log.ErrorLevel, log.WarnLevel, log.InfoLevel, log.DebugLevel, } } ``` 在上面的示例代码中，我们创建了两个日志文件，分别为 `log1.log` 和 `log2.log`，并使用 `logrusWriter` 将日志同时输出到这两个文件中。可以根据需要添加更多的文件和 `logrusWriter` 实例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值