golang批量写入elasticsearch

最新推荐文章于 2024-02-11 20:19:39 发布
最新推荐文章于 2024-02-11 20:19:39 发布
阅读量4.2k 收藏 3
点赞数
分类专栏： elasticsearch Go 文章标签： golang elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zt102545/article/details/122087524
版权

文章目录

需求

需要将阿里云CDN的离线日志每天自动化写入到elasticsearch，方便查看。

ES写入

使用olivere/elastic组件
单携程批量写入用Bulk，数据量上来之后一定会出现性能瓶颈
后改用多携程用BulkProcessor

// ReadLineFile 同步方式，使用Bulk批量写入
func ReadLineFile(index int, fileName string, elk *Elk) {
	if file, err := os.Open(fileName); err != nil {
		panic(err)
	} else {
		defer file.Close()
		scanner := bufio.NewScanner(file)
		bulkRequest := elk.Client.Bulk()
		i := 0
		n := 0
		date := time.Now().AddDate(0, 0, -1).Format("2006-01-02")
		for scanner.Scan() {
			i++
			n++
			cdn := toStruct(scanner.Text())
			date = cdn.Time.Format("2006-01-02")
			req := elastic.NewBulkIndexRequest().Index("cdnlog-" + date).Doc(cdn)
			bulkRequest = bulkRequest.Add(req)
			if i > 9999 {
				fmt.Println(n)
				i = 0
				_, err := bulkRequest.Do(context.Background())
				if err != nil {
					fmt.Println(fmt.Sprintf("bulkResponse:%v count:%v is err:%v", index, bulkRequest.NumberOfActions(), err.Error()))
				} else {
					bulkRequest = elk.Client.Bulk()
				}
			}
		}
		bulkResponse, err := bulkRequest.Do(context.Background())
		if err != nil {
			fmt.Println(err)
		}
		if bulkResponse != nil {
			fmt.Println(n)
		}
	}
}

// ReadLineFileSync 异步的方式，使用BulkProcessor
func ReadLineFileSync(index int, fileName string, elk *Elk) {
	if file, err := os.Open(fileName); err != nil {
		panic(err)
	} else {
		defer file.Close()
		scanner := bufio.NewScanner(file)
		w, _ := elk.Client.BulkProcessor().
			BulkActions(bulkActions).        //每个携程队列容量
			FlushInterval(time.Millisecond). //刷新间隔
			Workers(workerNum).              //携程数
			Stats(true).                     //是否获取统计信息
			After(GetFailed).                //刷新后回调函数
			Do(context.Background())
		w.Start(context.Background())
		defer w.Close() //关闭并提交所有队列里的数据，一定要做
		i := 0
		n := 0
		date := time.Now().AddDate(0, 0, -1).Format("2006-01-02")
		for scanner.Scan() {
			i++
			n++
			cdn := toStruct(scanner.Text())
			date = cdn.Time.Format("2006-01-02")
			req := elastic.NewBulkIndexRequest().Index("cdnlog-" + date).Doc(cdn)
			w.Add(req) //这里不用显示调用Do 因为上面定义了两个写入的触发条件
			if i > 99999 {
				i = 0
				st := w.Stats() //获取数据写入情况
				log.Printf("BulkMonitor state Succeeded:%d Failed:%d Created:%d Updated:%d Deleted:%d Flushed:%d Committed:%d Indexed:%d\n", st.Succeeded, st.Failed, st.Created, st.Updated, st.Deleted, st.Flushed, st.Committed, st.Indexed)
				fmt.Println(fmt.Sprintf("index:%v count:%v", index, n))
				for _, s := range st.Workers {
					log.Println("BulkMonitor Queue:", s.Queued) //这里打印每个worker的队列里面有多少数据
				}
			}
		}
		fmt.Println(fmt.Sprintf("index:%v count:%v", index, n))
	}
}

//GetFailed 是发生数据写入失败时获取详情的回调函数
func GetFailed(executionId int64, requests []elastic.BulkableRequest, response *elastic.BulkResponse, err error) {
	if response == nil { //可能存在为空的情况 😳
		log.Println("GetNil response return")
		return
	}
	fi := response.Failed()
	if len(fi) != 0 {
		for _, f := range fi {
			log.Printf("DebugFailedEs: index:%s type:%s id:%s version:%d  status:%d result:%s ForceRefresh:%v errorDetail:%v getResult:%v\n", f.Index, f.Type, f.Id, f.Version, f.Status, f.Result, f.ForcedRefresh, f.Error, f.GetResult)
		}
	}
}

func NewElk(url, user, password string) (*Elk, error) {
	Es, err := elastic.NewClient(
		elastic.SetSniff(false),
		elastic.SetURL(url),
		elastic.SetBasicAuth(user, password),
	)
	if err != nil {
		return nil, err
	}

	e := &Elk{
		Client: Es,
	}
	return e, nil
}

阿里云CDN的API

package common

import (
	openapi "github.com/alibabacloud-go/darabonba-openapi/client"
	dcdn20180115 "github.com/alibabacloud-go/dcdn-20180115/client"
	"github.com/alibabacloud-go/tea/tea"
)

const (
	AccessKeyId     = "LTAI5txxxxxUzoNCnrc"
	AccessKeySecret = "81UquYxxxxQtW7Q7m19loXg"
	Endpoint        = "dcdn.aliyuncs.com"
	DomainName      = "vvin.gwxxxek.com"
)

func CreateClient(accessKeyId *string, accessKeySecret *string) (_result *dcdn20180115.Client, _err error) {
	config := &openapi.Config{
		// 您的AccessKey ID
		AccessKeyId: accessKeyId,
		// 您的AccessKey Secret
		AccessKeySecret: accessKeySecret,
	}
	// 访问的域名
	config.Endpoint = tea.String(Endpoint)
	_result = &dcdn20180115.Client{}
	_result, _err = dcdn20180115.NewClient(config)
	return _result, _err
}

func GetDownData(startTime,endTime string) (paths []string, _err error) {
	paths = make([]string, 0)
	client, _err := CreateClient(tea.String(AccessKeyId), tea.String(AccessKeySecret))
	if _err != nil {
		return paths, _err
	}

	describeDcdnDomainLogRequest := &dcdn20180115.DescribeDcdnDomainLogRequest{
		DomainName: tea.String(DomainName),
		StartTime: tea.String(startTime),
		EndTime: tea.String(endTime),
	}
	// 复制代码运行请自行打印 API 的返回值
	res, _err := client.DescribeDcdnDomainLog(describeDcdnDomainLogRequest)
	if _err != nil {
		return paths, _err
	}
	for _, DomainLogDetail := range res.Body.DomainLogDetails.DomainLogDetail {
		for _, LogInfoDetail := range DomainLogDetail.LogInfos.LogInfoDetail {
			paths = append(paths, tea.StringValue(LogInfoDetail.LogPath))
		}
	}
	//fmt.Println(res)
	return paths, _err
}

整体代码

package main

import (
	"bufio"
	"compress/gzip"
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"toolTest/common"

	"github.com/olivere/elastic/v7"
)

type Elk struct {
	Client *elastic.Client
}

type Cdn struct {
	Time         time.Time
	DateTime     string
	Ip           string
	Country      string
	Vpn          string
	ResponseTime string
	Referer      string
	Method       string
	Url          string
	HttpCode     string
	RequestSize  string
	ResponseSize string
	CacheStatus  string
	UAHeard      string
	ContentType  string
	Content      string
	LogModule    string
}

const (
	url         = "http://es-cn-zv5xxxxx.elasticsearch.aliyuncs.com:9200"
	user        = "elastic"
	password    = "000000"
	bulkActions = 5000
	workerNum   = 20
	TimeForm    = "2/Jan/2006:15:04:05"
	TimeForm2   = "2006-01-02 15:04:05"
)

func main() {
	StartRunCdn()
}

func StartRunCdn() {
	//ip.InitRegion()
	sysPath, _ := os.Getwd()
	dirPath := sysPath + "\\CndLog"
	_, err := os.Stat(dirPath)
	if err != nil {
		if os.IsNotExist(err) {
			err = os.Mkdir(dirPath, 0777)
			if err != nil {
				fmt.Println(fmt.Sprintf("mkdir path:%v,is err:%v", dirPath, err.Error()))
				return
			}
		} else {
			fmt.Println(fmt.Sprintf("mkdir path:%v,is err:%v", dirPath, err.Error()))
			return
		}
	}
	startTime, err := time.Parse(TimeForm2, "2021-12-21 00:00:00")
	if err != nil {
		fmt.Println(err.Error())
	}
	endTime, err := time.Parse(TimeForm2, "2021-12-21 01:00:00")
	if err != nil {
		fmt.Println(err.Error())
	}
	elk, err := NewElk(url, user, password)
	if err != nil {
		fmt.Println(fmt.Sprintf("NewElk is err:%v", err.Error()))
		return
	}
	for j := 0; j < 1; j++ {
		startTimeStr := startTime.AddDate(0, 0, j).Format("2006-01-02T15:04:05Z")
		endTimeStr := endTime.AddDate(0, 0, j).Format("2006-01-02T15:04:05Z")
		paths, _ := common.GetDownData(startTimeStr, endTimeStr)//调用API获取下载路径
		fmt.Println(fmt.Sprintf("startTime:%s;\nendTime:%s;\npwd:%s;\npathCount:%v;\npath:%v", startTimeStr, endTimeStr, sysPath, len(paths), paths))
		RunTask(elk, dirPath, paths)
	}
}

func RunTask(elk *Elk, dirPath string, paths []string) {
	//var wg sync.WaitGroup
	for i, path := range paths {
		//wg.Add(1)
		func(index int) {
			//defer wg.Done()
			fmt.Println(path)
			logTime := time.Now().Format("2006-01-02T")
			gzipPath := dirPath + "\\" + logTime + strconv.Itoa(index) + ".gz"
			filePath := dirPath + "\\" + logTime + strconv.Itoa(index) + ".txt"
			err := downloadFile("https://"+path, gzipPath)//下载文件
			if err != nil {
				fmt.Println(fmt.Sprintf("path:%v;gzipPath:%v;downloadFile:%v", path, gzipPath, err.Error()))
			}
			err = ReadGzipFile(gzipPath, filePath)//解压文件
			if err != nil {
				fmt.Println(fmt.Sprintf("gzipPath:%v;filePath:%v;ReadGzipFile:%v", gzipPath, filePath, err.Error()))
			}
			ReadLineFileSync(index, filePath, elk)//读取文件并写入ES
			err = os.RemoveAll(gzipPath)//删除下载文件
			if err != nil {
				fmt.Println("del dir error:", err)
			}
			err = os.RemoveAll(filePath)//删除解压文件
			if err != nil {
				fmt.Println("del dir error:", err)
			}
		}(i)
	}
	//wg.Wait()
}

// toStruct cdn数据转结构体
func toStruct(str string) (cdn *Cdn) {
	arrStr := strings.Split(str, " ")
	if len(arrStr) > 0 {
		defer func() {
			if err := recover(); err != nil {
				fmt.Println(err)
			}
		}()
		cdnTime, err := time.Parse(TimeForm, strings.TrimLeft(arrStr[0], "["))
		if err != nil {
			fmt.Println(err.Error())
		}
		//c, err := ip.GetCountry(arrStr[2])
		//if err != nil {
		//	fmt.Println(err.Error())
		//}
		cdn = &Cdn{
			LogModule:    "CDN",
			Content:      str,
			Time:         cdnTime,
			DateTime:     arrStr[0] + arrStr[1],
			Ip:           arrStr[2],
			//Country:      c.Country.Names["zh-CN"],
			Vpn:          arrStr[3],
			ResponseTime: arrStr[4],
			Referer:      arrStr[5],
			Method:       arrStr[6],
			Url:          arrStr[7],
			HttpCode:     arrStr[8],
			RequestSize:  arrStr[9],
			ResponseSize: arrStr[10],
			CacheStatus:  arrStr[11],
		}
		if arrStr[len(arrStr)-1] == "charset=UTF-8\"" && arrStr[len(arrStr)-2] == "\"text/html;" {
			for i := 12; i < len(arrStr)-2; i++ {
				cdn.UAHeard += arrStr[i]
			}
			cdn.ContentType = arrStr[len(arrStr)-2] + arrStr[len(arrStr)-1]
		} else {
			for i := 12; i < len(arrStr)-1; i++ {
				cdn.UAHeard += arrStr[i]
			}
			cdn.ContentType = arrStr[len(arrStr)-1]
		}
	}
	return cdn
}

func downloadFile(url string, path string) error {
	// Get the data
	resp, err := http.Get(url)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	// Create output file
	out, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0777)
	if err != nil {
		return err
	}
	defer out.Close()
	// copy stream
	_, err = io.Copy(out, resp.Body)
	if err != nil {
		return err
	}
	return err
}

func ReadGzipFile(url string, path string) error {
	gzipFile, _ := os.Open(url)
	defer gzipFile.Close()
	gzipReader, _ := gzip.NewReader(gzipFile)
	defer gzipReader.Close()
	outfileWriter, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0777)
	defer outfileWriter.Close()
	if err != nil {
		return err
	}

	// 复制内容
	_, err = io.Copy(outfileWriter, gzipReader)
	if err != nil {
		return err
	}
	return err
}

BulkProcessor流程图

在这里插入图片描述

zzvine
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Elasticsearch的官方Go客户-Golang开发
05-26
go-elasticsearch Elasticsearch的官方Go客户。 兼容性客户端主要版本与兼容的Elasticsearch主要版本相对应：要连接到Elasticsearch 7.x，请使用7.x版本go-elasticsearch Elasticsearch的官方Go客户端。 兼容性客户端主要版本与兼容的Elasticsearch主要版本相对应：要连接到Elasticsearch 7.x，请使用客户端的7.x版本，要连接到Elasticsearch 6.x，请使用客户端的6.x版本。 使用Go模块时，请在导入路径中包含版本，并指定显式版本或分支：require github.com/elastic/go-elasticsearch/v7 7.x需要github.com/elastic/go-elas
golang写的文件批量删除工具delete_tool.exe
06-05
golang写的文件批量删除工具delete_tool.exe
go从0到1项目实战体系三十九：elastic使用
最新发布
wanmeijuhao的博客
02-11 148
【代码】go从0到1项目实战体系三十九：elastic使用。
elasticsql：在Golang中将sql转换为elasticsearch DSL（go）
01-30
_____ _ _ ____ _____ ___ ____ ____ ___ _ | ____| | / \ / ___|_ _|_ _|/ ___|/ ___| / _ \ | | | _| | | / _ \ \___ \ | | | || | \___ \| | | || | | |___| |___ / ___ \ ___) || | | || |___ ___) | |_| || |___ |_____|_____|/_/ \_\|____/ |_| |___|\____||____/ \__\_\|_____| 总览 该工具将sql转换为elasticsearch dsl 目前支持： sql和表达式 sql或表达式 等于（=）支持 不等于（！=）支持 gt（>）支持 gte（> =）支持 lt（<）支持 lte（<=）支持 sql in（例如（1,2,3）中的id）表达式 sql不在（例如id不在（1,2,3））表达式中 paren bool支持（例如，其中（
一个基于Go（golang）的Elasticsearch客户端库。-Golang开发
05-26
elastigo v2.0非常感谢@alicebob帮助使drone.io CI正常工作（注意：徽章已被缓存，已知问题）。 一个基于Go（Golang）的Elasticsearch客户端，实现了用于索引和搜索的核心api。 GoDoc h elastigo v2.0非常感谢@alicebob帮助drone.io CI正常工作（注意：徽章已被缓存，已知问题）。 一个基于Go（Golang）的Elasticsearch客户端，实现了用于索引和搜索的核心api。 GoDoc http://godoc.org/github.com/mattbaird/elastigo注意：基于Jeremy Shute的出色工作，Elastigo现在支持多个连接。 我们试图使它向后兼容，但是最终却不可能，因此我们将较旧的单个连接代码标记为
Golang实战之海量日志收集系统（八）logTransfer之将日志入库到Elasticsearch并通过Kibana进行展示
普通Gopher
03-28 1927
前面我们将logTransfor的配置初始化成功了, 下面将从Kafka中消费数据, 并将日志入库到Elasticsearch并通过Kibana进行展示 将日志保存到ES中 初始化Es 在main函数中添加初始化InitEs函数 // 初始化Es err = es.InitEs(logConfig.EsAddr) if err != nil { logs.Error("初始化Elastic...
go语言 elasticsearch 批量写入_Go语言是如何操作elasticsearch的
weixin_39630441的博客
01-12 1358
1、前提1.1 docker 安装elasticsearch查询elasticsearch 版本docker search elasticsearch将对应的版本拉到本地docker.elastic.co/elasticsearch/elasticsearch:7.3.0创建一个网络docker network create esnet启动容器docker run --name es -p 920...
Golang使用Elasticsearch
m0_67391870的博客
03-25 1755
创建es.go文件 根据elasticsearch版本拉取对应的go包：github.com/elastic/go-elasticsearch API文档：https://pkg.go.dev/github.com/elastic/go-elasticsearch/[email protected]/esapi?tab=doc package es import ( "bytes" "context" "encoding/json" "fmt" "github.com/elastic/go-elasticsea
go写es简单例子
talen_hx的博客
04-07 299
package main import ( "context" "fmt" "github.com/olivere/elastic/v7" ) type Person struct { Name string `json:"name"` Age int `json:"age"` Married bool `json:"married"` } func main() { client, err := elastic.NewClient(elastic.SetUR.
Golang 操作Elastic进行插入数据，查询与模糊查询
qq_42690129的博客
07-07 1602
Golang 操作Elastic进行插入数据，查询与模糊查询
go日志输入到es
weixin_30566111的博客
06-25 306
1.依赖 github.com/alecthomas/log4go 2.配置 <filter enabled="true"><!-- enabled=false means this logger won't actually be created --> <tag>donotopen</tag> ...
golang操作elasticsearch的实现
12-17
1.1 docker 安装elasticsearch 查询elasticsearch 版本 docker search elasticsearch 将对应的版本拉到本地 docker.elastic.co/elasticsearch/elasticsearch:7.3.0 创建一个网络 docker network create esnet ...
Golang操作ES
qq_39280718的博客
09-24 2476
Golang操作ES
Golang并发读取文件数据并写入数据库
Monkey_D_Newdun的博客
01-24 4731
记录一下用Golang做并发，创建多个goroutine去读取指定目录下的多个JSON格式的数据文件，并将其每条数据格式化后写入到Oracle数据库
go语言操作es
qq_53267860的博客
03-13 6606
目录go语言操作es解决golang使用elastic连接elasticsearch时自动转换连接地址初始化数据创建结构体方式字符串方式：查找修改删除查找集群搭建配置文件修改 go语言操作es go get github.com/olivere/elastic 解决golang使用elastic连接elasticsearch时自动转换连接地址 elastic.SetSniff(false) client, _ := elastic.NewClient( // ... // 将sniff设置为
go语言批量bulk操作elasticsearch8报错解决：The bulk request must be terminated by a newline [\n]，es8bulk批量插入问题解决
weixin_42151366的博客
10-12 3544
go语言批量bulk操作elasticsearch8报错解决The bulk request must be terminated by a newline [\n]问题
elasticsearch原理简析服务器上安装Python和golang语言下的数据写入和查询简单实战演练
HUSTHY的博客
11-15 470
一、elasticsearch原理简析 二、服务器上的安装 三、实战演练相关 Python语言版本 1、数据增删改相关 2、数据查询相关 golang语言版本 1、数据增删改相关 2、数据查询相关
ElasticSearch7的简单使用
罗罗的1024
09-21 959
简介 es开箱即用 es建立索引快，查询慢 es仅仅支持json格式 yum安装 1、下载并安装ES的YUM公钥 rpm --import https://packages.elastic.co/GPG-KEY-elasticsearch 2、配置ELASTICSEARCH的YUM源 vim /etc/yum.repos.d/elasticsearch.repo [elasticsearch-7.x] name=Elasticsearch repository for 7.x packages bas
golang数据结构操作库
07-28
引用\[1\]中提到了golang中string的数据结构定义，即stringStruct。这个结构体包含了一个指向字符串的指针和字符串的长度。在引用\[2\]中，我们可以看到在字符串生成时，会先构建stringStruct对象，然后再将其转换成string类型。具体的转换过程可以在gostringnocopy函数中找到。该函数接受一个指向字节数组的指针，然后通过构造stringStruct对象，再将其转换成string类型返回。 除了字符串的数据结构操作，golang还提供了其他数据结构的操作库。例如，对于数组和切片，可以使用内置的函数和方法来进行操作，如append、copy、len和cap等。对于映射(map)和结构体(struct)，可以使用点操作符来访问和修改其字段。此外，golang还提供了一些包来处理常见的数据结构，如container包中的堆(heap)和列表(list)等。 总之，golang提供了丰富的数据结构操作库，可以满足不同场景下的需求。通过使用这些库，开发者可以方便地对数据结构进行创建、访问和修改等操作。 #### 引用[.reference_title] - *1* *2* *3* [golang数据结构初探之字符串string](https://blog.csdn.net/dong945221578/article/details/119870727)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值