Elasticsearch Go 客户端

本文代码来自于官方示例。

一、配置

此例演示的是配置客户端的传输Transport。

类例中的配置主要用于说明其作用，不适用于生产环境。

默认的传输就够用了。

package main

import (
    "github.com/elastic/go-elasticsearch/v8"
)

func main() {
    cfg := elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
        Transport: &http.Transport{
            MaxIdleConnsPerHost:   10,
            ResponseHeaderTimeout: time.Millisecond,
            DialContext:           (&net.Dialer{Timeout: time.Nanosecond}).DialContext,
            TLSClientConfig: &tls.Config{
                MinVersion: tls.VersionTLS11,
            },
        },
    }

    es, err := elasticsearch.NewClient(cfg)
    if err != nil {
        panic(err)
    }

    resp, err := es.Info()
    if err != nil {
        panic(err)
    }
    fmt.Println(resp)
    // => panic: dial tcp: i/o timeout
}

二、自定义传输

自定义传输用于读取或操作请求和响应，自定义日志记录，将自定义 header 传递给请求等。

CountingTransport将自定义 header 添加到请求，记录有关请求和响应的信息，并统计请求次数。

由于它实现了http.RoundTripper接口，因此可以将其作为自定义 HTTP 传输实现传递给客户端。

type CountingTransport struct {
    count uint64
}

// RoundTrip 发送一个请求，返回一个响应
func (t *CountingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    var buf bytes.Buffer

    atomic.AddUint64(&t.count, 1)

    req.Header.Set("Accept", "application/yaml")
    req.Header.Set("X-Request-ID", "foo-123")

    res, err := http.DefaultTransport.RoundTrip(req)

    buf.WriteString(strings.Repeat("-", 80) + "\n")
    fmt.Fprintf(&buf, "%s %s", req.Method, req.URL.String())

    if err != nil {
        fmt.Fprintf(&buf, "ERROR: %s\n", err)
    } else {
        fmt.Fprintf(&buf, "[%s] %s\n", res.Status, res.Header.Get("Content-Type"))
    }

    buf.WriteTo(os.Stdout)

    return res, err
}

func main() {
    var wg sync.WaitGroup

    // 创建一个自定义传输
    tp := new(CountingTransport)

    // 将自定义传输放到客户端配置中
    es, _ := elasticsearch.NewClient(elasticsearch.Config{Transport: tp})

    for i := 0; i < 25; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            es.Info()
        }()
    }

    wg.Wait()

    fmt.Println(strings.Repeat("=", 80))
    fmt.Printf("%80s\n", fmt.Sprintf("Total Requests: %d", atomic.LoadUint64(&tp.count)))
}

三、日志

1 使用默认日志

默认日志有以下四种：

• estransport.TextLogger
• estransport.ColorLogger
• estransport.CurlLogger
• estransport.JSONLogger

func main() {
    log.SetFlags(0)

    var es *elasticsearch.Client

    es, _ = elasticsearch.NewClient(elasticsearch.Config{
        Logger: &estransport.TextLogger{Output: os.Stdout},
    })
    run(es, "Text")

    es, _ = elasticsearch.NewClient(elasticsearch.Config{
        Logger: &estransport.ColorLogger{Output: os.Stdout},
    })
    run(es, "Color")

    es, _ = elasticsearch.NewClient(elasticsearch.Config{
        Logger: &estransport.ColorLogger{
            Output:             os.Stdout,
            EnableRequestBody:  true,
            EnableResponseBody: true,
        },
    })
    run(es, "Request/Response body")

    es, _ = elasticsearch.NewClient(elasticsearch.Config{
        Logger: &estransport.CurlLogger{
            Output:             os.Stdout,
            EnableRequestBody:  true,
            EnableResponseBody: true,
        },
    })
    run(es, "Curl")

    es, _ = elasticsearch.NewClient(elasticsearch.Config{
        Logger: &estransport.JSONLogger{
            Output: os.Stdout,
        },
    })
    run(es, "JSON")
}

func run(es *elasticsearch.Client, name string) {
    log.Println("███", fmt.Sprintf("\x1b[1m%s\x1b[0m", name), strings.Repeat("█", 75-len(name)))

    es.Delete("test", "1")
    es.Exists("test", "1")

    es.Index(
        "test",
        strings.NewReader(`{"title": "logging"}`),
        es.Index.WithRefresh("true"),
        es.Index.WithPretty(),
        es.Index.WithFilterPath("result", "_id"),
    )

    es.Search(es.Search.WithQuery("{FAIL"))

    res, err := es.Search(
        es.Search.WithIndex("test"),
        es.Search.WithBody(strings.NewReader(`{"query": {"match": {"title": "logging"}}}`)),
        es.Search.WithSize(1),
        es.Search.WithPretty(),
        es.Search.WithFilterPath("took", "hits.hits"),
    )

    s := res.String()

    if len(s) <= len("[200 OK] ") {
        log.Fatal("Response body is empty")
    }

    if err != nil {
        log.Fatalf("Error: %s", err)
    }

    log.Println()
}

四种日志的用途：

• TextLogger：将请求和响应的基本信息以明文的形式输出
• ColorLogger：在开发时能在终端将一些信息以不同颜色输出
• CurlLogger：将信息格式化为可运行的curl命令，当启用EnableResponseBody时会美化输出
• JSONLogger：将信息以 json 格式输出，适用于生产环境的日志

如果要记录请求和响应的 body 内容，需要开启对应的选项：

• EnableRequestBody：记录请求体
• EnableResponseBody：记录响应体

2 自定义日志

根据estransport.Logger接口，实现自定义日志。

日志包使用rs/zerolog。

package main

import (
    "github.com/rs/zerolog"
)

// CustomLogger 实现 estransport.Logger 接口
type CustomLogger struct {
    zerolog.Logger
}

// LogRoundTrip 打印请求和响应的一些信息
func (l *CustomLogger) LogRoundTrip(
    req *http.Request,
    res *http.Response,
    err error,
    start time.Time,
    dur time.Duration,
) error {
    var (
        e    *zerolog.Event
        nReq int64
        nRes int64
    )

    // 设置日志等级
    switch {
    case err != nil:
        e = l.Error()
    case res != nil && res.StatusCode > 0 && res.StatusCode < 300:
        e = l.Info()
    case res != nil && res.StatusCode > 299 && res.StatusCode < 500:
        e = l.Warn()
    case res != nil && res.StatusCode > 499:
        e = l.Error()
    default:
        e = l.Error()
    }

    // 计算请求体和响应体的字节数
    if req != nil && req.Body != nil && req.Body != http.NoBody {
        nReq, _ = io.Copy(ioutil.Discard, req.Body)
    }
    if res != nil && res.Body != nil && res.Body != http.NoBody {
        nRes, _ = io.Copy(ioutil.Discard, res.Body)
    }

    // 日志事件
    e.Str("method", req.Method).
        Int("status_code", res.StatusCode).
        Dur("duration", dur).
        Int64("req_bytes", nReq).
        Int64("res_bytes", nRes).
        Msg(req.URL.String())

    return nil
}

// RequestBodyEnabled 输出请求体
func (l *CustomLogger) RequestBodyEnabled() bool { return true }

// ResponseBodyEnabled 输出响应体
func (l *CustomLogger) ResponseBodyEnabled() bool { return true }

func main() {

    // 设置日志
    log := zerolog.New(zerolog.ConsoleWriter{Out: os.Stderr}).
        Level(zerolog.InfoLevel).
        With().
        Timestamp().
        Logger()

    // 客户端使用自定义的日志
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Logger: &CustomLogger{log},
    })

    {
        es.Delete("test", "1")
        es.Exists("test", "1")
        es.Index("test", strings.NewReader(`{"title": "logging"}`), es.Index.WithRefresh("true"))

        es.Search(
            es.Search.WithQuery("{FAIL"),
        )

        es.Search(
            es.Search.WithIndex("test"),
            es.Search.WithBody(strings.NewReader(`{"query": {"match": {"title": "logging"}}}`)),
            es.Search.WithSize(1),
        )
    }
}

结果如图：

四、批量索引

1 默认

此示例有意不使用任何抽象或辅助功能来展示使用 bulk api 的低级机制：准备元数据有效载荷，批量发送有效载荷，检查错误结果并打印报告。

请看代码注释：

package main

import (
    "github.com/dustin/go-humanize"
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/elastic/go-elasticsearch/v8/esapi"
)

type Article struct {
    ID        int       `json:"id"`
    Title     string    `json:"title"`
    Body      string    `json:"body"`
    Published time.Time `json:"published"`
    Author    Author    `json:"author"`
}

type Author struct {
    FirstName string `json:"first_name"`
    LastName string `json:"last_name"`
}

var (
    _     = fmt.Print
    count int
    batch int
)

func init() {
    flag.IntVar(&count, "count", 1000, "生成的文档数量")
    flag.IntVar(&batch, "batch", 255, "每次发送的文档数量")
    flag.Parse()

    rand.Seed(time.Now().UnixNano())
}

func main() {
    log.SetFlags(0)

    type bulkResponse struct {
        Errors bool `json:"errors"`
        Items  []struct {
            Index struct {
                ID     string `json:"_id"`
                Result string `json:"result"`
                Status int    `json:"status"`
                Error  struct {
                    Type   string `json:"type"`
                    Reason string `json:"reason"`
                    Cause  struct {
                        Type   string `json:"type"`
                        Reason string `json:"reason"`
                    } `json:"caused_by"`
                } `json:"error"`
            } `json:"index"`
        } `json:"items"`
    }

    var (
        buf bytes.Buffer
        res *esapi.Response
        err error
        raw map[string]interface{}
        blk *bulkResponse

        articles  []*Article
        indexName = "articles"

        numItems   int
        numErrors  int
        numIndexed int
        numBatches int
        currBatch  int
    )

    log.Printf(
        "\x1b[1mBulk\x1b[0m: documents [%s] batch size [%s]",
        humanize.Comma(int64(count)), humanize.Comma(int64(batch)))
    log.Println(strings.Repeat("_", 65))

    // 创建客户端
    es, err := elasticsearch.NewDefaultClient()
    if err != nil {
        panic(err)
    }

    // 生成文章
    names := []string{"Alice", "John", "Mary"}
    for i := 1; i < count+1; i++ {
        articles = append(articles, &Article{
            ID:        i,
            Title:     strings.Join([]string{"Title", strconv.Itoa(i)}, " "),
            Body:      "Lorem ipsum dolor sit amet...",
            Published: time.Now().Round(time.Second).Local().AddDate(0, 0, i),
            Author: Author{
                FirstName: names[rand.Intn(len(names))],
                LastName: "Smith",
            },
        })
    }
    log.Printf("→ Generated %s articles", humanize.Comma(int64(len(articles))))
    fmt.Println("→ Sending batch ")

    // 重新创建索引
    if res, err = es.Indices.Delete([]string{indexName}); err != nil {
        log.Fatalf("Cannot delete index: %s", err)
    }

    res, err = es.Indices.Create(indexName)
    if err != nil {
        log.Fatalf("Cannot create index: %s", err)
    }

    if res.IsError() {
        log.Fatalf("Cannot create index: %s", res)
    }

    if count%batch == 0 {
        numBatches = count / batch
    } else {
        numBatches = count/batch + 1
    }

    start := time.Now().Local()

    // 循环收集
    for i, a := range articles {
        numItems++

        currBatch = i / batch
        if i == count-1 {
            currBatch++
        }

        // 准备元数据有效载荷
        meta := []byte(fmt.Sprintf(`{ "index" : { "_id" : "%d" } }%s`, a.ID, "\n"))

        // 准备 data 有效载荷：序列化后的 article
        data, err := json.Marshal(a)
        if err != nil {
            log.Fatalf("Cannot encode article %d: %s", a.ID, err)
        }

        // 在 data 载荷中添加一个换行符
        data = append(data, "\n"...)

        // 将载荷添加到 buf 中
        buf.Grow(len(meta) + len(data))
        buf.Write(meta)
        buf.Write(data)

        // 达到阈值时，使用 buf 中的数据（请求体）执行 Bulk() 请求
        if i > 0 && i%batch == 0 || i == count-1 {
            fmt.Printf("[%d/%d] ", currBatch, numBatches)

            // 每 batch（本例中是255）个为一组发送
            res, err = es.Bulk(bytes.NewReader(buf.Bytes()), es.Bulk.WithIndex(indexName))
            if err != nil {
                log.Fatalf("Failur indexing batch %d: %s", currBatch, err)
            }

            // 如果整个请求失败，打印错误并标记所有文档都失败
            if res.IsError() {
                numErrors += numItems
                if err := json.NewDecoder(res.Body).Decode(&raw); err != nil {
                    log.Fatalf("Failure to parse response body: %s", err)
                } else {
                    log.Printf(" Error: [%d] %s: %s",
                        res.StatusCode,
                        raw["error"].(map[string]interface{})["type"],
                        raw["error"].(map[string]interface{})["reason"],
                    )
                }
            } else {  // 一个成功的响应也可能因为一些特殊文档包含一些错误
                if err := json.NewDecoder(res.Body).Decode(&blk); err != nil {
                    log.Fatalf("Failure to parse response body: %s", err)
                } else {
                    for _, d := range blk.Items {
                        // 对任何状态码大于 201 的请求进行处理
                        if d.Index.Status > 201 {
                            numErrors++
                            log.Printf("  Error: [%d]: %s: %s: %s: %s",
                                d.Index.Status,
                                d.Index.Error.Type,
                                d.Index.Error.Reason,
                                d.Index.Error.Cause.Type,
                                d.Index.Error.Cause.Reason,
                            )
                        } else {
                            // 如果状态码小于等于 201，对成功的计数器 numIndexed 加 1
                            numIndexed++
                        }
                    }
                }
            }

            // 关闭响应体，防止达到 Goroutines 或文件句柄限制
            res.Body.Close()


            // 重置 buf 和 items 计数器
            buf.Reset()
            numItems = 0
        }
    }

    // 报告结果：索引成功的文档的数量，错误的数量，耗时，索引速度
    fmt.Println()
    log.Println(strings.Repeat("▔", 65))

    dur := time.Since(start)

    if numErrors > 0 {
        log.Fatalf(
            "Indexed [%s] documents with [%s] errors in %s (%s docs/sec)",
            humanize.Comma(int64(numIndexed)),
            humanize.Comma(int64(numErrors)),
            dur.Truncate(time.Millisecond),
            humanize.Comma(int64(1000.0/float64(dur/time.Millisecond)*float64(numIndexed))),
        )
    } else {
        log.Printf(
            "Successfuly indexed [%s] documents in %s (%s docs/sec)",
            humanize.Comma(int64(numIndexed)),
            dur.Truncate(time.Millisecond),
            humanize.Comma(int64(1000.0/float64(dur/time.Millisecond)*float64(numIndexed))),
        )
    }
}

count和batch为可选参数，在执行时可以自定义：

➜ go run main.go -count=100000 -batch=25000

Bulk: documents [100,000] batch size [25,000]
▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
→ Generated 100,000 articles
→ Sending batch
[1/4] [2/4] [3/4] [4/4]
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
Successfuly indexed [100,000] documents in 2.79s (35,842 docs/sec)

2 索引器

此例演示使用esutil.BulkIndexer帮助程序来索引文档。

package main

import (
    "github.com/dustin/go-humanize"
    "github.com/cenkalti/backoff/v4"

    "github.com/elastic/go-elasticsearch/v8"
    "github.com/elastic/go-elasticsearch/v8/esapi"
    "github.com/elastic/go-elasticsearch/v8/esutil"
)

type Article struct {
    ID        int       `json:"id"`
    Title     string    `json:"title"`
    Body      string    `json:"body"`
    Published time.Time `json:"published"`
    Author    Author    `json:"author"`
}

type Author struct {
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
}

var (
    indexName  string
    numWorkers int
    flushBytes int
    numItems   int
)

func init() {
    flag.StringVar(&indexName, "index", "test-bulk-example", "索引名称")
    flag.IntVar(&numWorkers, "workers", runtime.NumCPU(), "工作进程数量")
    flag.IntVar(&flushBytes, "flush", 5e+6, "以字节为单位的清除阈值")
    flag.IntVar(&numItems, "count", 10000, "生成的文档数量")
    flag.Parse()

    rand.Seed(time.Now().UnixNano())
}

func main() {
    log.SetFlags(0)

    var (
        articles        []*Article
        countSuccessful uint64

        res *esapi.Response
        err error
    )

    log.Printf(
        "\x1b[1mBulkIndexer\x1b[0m: documents [%s] workers [%d] flush [%s]",
        humanize.Comma(int64(numItems)), numWorkers, humanize.Bytes(uint64(flushBytes)))
    log.Println(strings.Repeat("▁", 65))

    // 使用第三方包来实现回退功能
    retryBackoff := backoff.NewExponentialBackOff()

    // 创建客户端。如果想使用最佳性能，请考虑使用第三方 http 包，benchmarks 示例中有写
    es, err := elasticsearch.NewClient(elasticsearch.Config{
        // 429 太多请求
        RetryOnStatus: []int{502, 503, 504, 429},
        // 配置回退函数
        RetryBackoff: func(attempt int) time.Duration {
            if attempt == 1 {
                retryBackoff.Reset()
            }
            return retryBackoff.NextBackOff()
        },
        // 最多重试 5 次
        MaxRetries: 5,
    })
    if err != nil {
        log.Fatalf("Error creating the client: %s", err)
    }

    // 创建批量索引器。要使用最佳性能，考虑使用第三方 json 包，benchmarks 示例中有写
    bi, err := esutil.NewBulkIndexer(esutil.BulkIndexerConfig{
        Index:         indexName, // 默认索引名
        Client:        es,  // es 客户端
        NumWorkers:    numWorkers, // 工作进程数量
        FlushBytes:    int(flushBytes), // 清除上限
        FlushInterval: 30 * time.Second, // 定期清除间隔
    })
    if err != nil {
        log.Fatalf("Error creating the indexer: %s", err)
    }

    // 生成文章
    names := []string{"Alice", "John", "Mary"}
    for i := 1; i <= numItems; i++ {
        articles = append(articles, &Article{
            ID:        i,
            Title:     strings.Join([]string{"Title", strconv.Itoa(i)}, " "),
            Body:      "Lorem ipsum dolor sit amet...",
            Published: time.Now().Round(time.Second).UTC().AddDate(0, 0, i),
            Author: Author{
                FirstName: names[rand.Intn(len(names))],
                LastName:  "Smith",
            },
        })
    }
    log.Printf("→ Generated %s articles", humanize.Comma(int64(len(articles))))

    // 重新创建索引
    if res, err = es.Indices.Delete([]string{indexName}, es.Indices.Delete.WithIgnoreUnavailable(true)); err != nil || res.IsError() {
        log.Fatalf("Cannot delete index: %s", err)
    }

    res.Body.Close()

    res, err = es.Indices.Create(indexName)
    if err != nil {
        log.Fatalf("Cannot create index: %s", err)
    }
    if res.IsError() {
        log.Fatalf("Cannot create index: %s", res)
    }
    res.Body.Close()

    start := time.Now().UTC()

    // 循环收集
    for _, a := range articles {
        // 准备 data：序列化的 article
        data, err := json.Marshal(a)
        if err != nil {
            log.Fatalf("Cannot encode article %d: %s", a.ID, err)
        }

        // 添加 item 到 BulkIndexer
        err = bi.Add(
            context.Background(),
            esutil.BulkIndexerItem{
                // Action 字段配置要执行的操作（索引、创建、删除、更新）
                Action:     "index",
                // DocumentID 是文档 ID（可选）
                DocumentID: strconv.Itoa(a.ID),
                // Body 是 有效载荷的 io.Reader
                Body:       bytes.NewReader(data),
                // OnSuccess 在每一个成功的操作后调用
                OnSuccess: func(c context.Context, bii esutil.BulkIndexerItem, biri esutil.BulkIndexerResponseItem) {
                    atomic.AddUint64(&countSuccessful, 1)
                },
                // OnFailure 在每一个失败的操作后调用
                OnFailure: func(c context.Context, bii esutil.BulkIndexerItem, biri esutil.BulkIndexerResponseItem, e error) {
                    if err != nil {
                        log.Printf("ERROR: %s", err)
                    } else {
                        log.Printf("ERROR: %s: %s", biri.Error.Type, biri.Error.Reason)
                    }
                },
            },
        )
        if err != nil {
            log.Fatalf("Unexpected error: %s", err)
        }
    }

    // 关闭索引器
    if err := bi.Close(context.Background()); err != nil {
        log.Fatalf("Unexpected error: %s", err)
    }

    biStats := bi.Stats()

    // 报告结果：索引成功的文档的数量，错误的数量，耗时，索引速度
    log.Println(strings.Repeat("▔", 65))

    dur := time.Since(start)

    if biStats.NumFailed > 0 {
        log.Fatalf(
            "Indexed [%s] documents with [%s] errors in %s (%s docs/sec)",
            humanize.Comma(int64(biStats.NumFlushed)),
            humanize.Comma(int64(biStats.NumFailed)),
            dur.Truncate(time.Millisecond),
            humanize.Comma(int64(1000.0/float64(dur/time.Millisecond)*float64(biStats.NumFlushed))),
        )
    } else {
        log.Printf(
            "Sucessfuly indexed [%s] documents in %s (%s docs/sec)",
            humanize.Comma(int64(biStats.NumFlushed)),
            dur.Truncate(time.Millisecond),
            humanize.Comma(int64(1000.0/float64(dur/time.Millisecond)*float64(biStats.NumFlushed))),
        )
    }
}

四个可选参数，见init()函数：

 ➜  bulk go run indexer.go --workers=8 --count=100000 --flush=1000000
 
BulkIndexer: documents [100,000] workers [8] flush [1.0 MB]
▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
→ Generated 100,000 articles
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
Sucessfuly indexed [100,000] documents in 1.584s (63,131 docs/sec)

五、编码

本示例中演示了如何使用 helper 方法和第三方 json 库。

1 第三方 json 库

1.1 tidwall/gjson

github.com/tidwall/gjson库允许在不将有效载荷转换为数据结构的前提下轻松访问属性。

package main

import (
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/fatih/color"
    "github.com/tidwall/gjson"
)

var (
    faint = color.New(color.Faint)
    bold  = color.New(color.Bold)
)

func init() {
    log.SetFlags(0)
}

func main() {
    es, err := elasticsearch.NewDefaultClient()
    if err != nil {
        log.Fatalf("Error creating client: %s", err)
    }

    res, err := es.Cluster.Stats(es.Cluster.Stats.WithHuman())
    if err != nil {
        log.Fatalf("Error getting response: %s", err)
    }
    defer res.Body.Close()

    json := read(res.Body)

    fmt.Println(strings.Repeat("-", 50))
    faint.Print("cluster ")
    // 获取集群名
    bold.Print(gjson.Get(json, "cluster_name"))

    faint.Print(" status=")
    // 获取集群健康状态
    status := gjson.Get(json, "status")
    switch status.Str {
    case "green":
        bold.Add(color.FgHiGreen).Print(status)
    case "yellow":
        bold.Add(color.FgHiYellow).Print(status)
    case "red":
        bold.Add(color.FgHiRed).Print(status)
    default:
        bold.Add(color.FgHiRed, color.Underline).Print(status)
    }
    fmt.Println("\n" + strings.Repeat("-", 50))

    stats := []string{
        "indices.count",
        "indices.docs.count",
        "indices.store.size",
        "nodes.count.total",
        "nodes.os.mem.used_percent",
        "nodes.process.cpu.percent",
        "nodes.jvm.versions.#.version",
        "nodes.jvm.mem.heap_used",
        "nodes.jvm.mem.heap_max",
        "nodes.fs.free",
    }

    var maxWidth int
    for _, item := range stats {
        if len(item) > maxWidth {
            maxWidth = len(item)
        }
    }

    for _, item := range stats {
        pad := maxWidth - len(item)
        fmt.Print(strings.Repeat(" ", pad))
        faint.Printf("%s |", item)
        // 从 json 动态获取状态
        fmt.Printf(" %s\n", gjson.Get(json, item))
    }
    fmt.Println()
}

func read(r io.Reader) string {
    var b bytes.Buffer
    b.ReadFrom(r)
    return b.String()
}

go run main.go

1.2 mailru/easyjson

mailru/easyjson可以用提供的结构体生成编码和解码的代码。

示例项目结构不适合在此处展示，故另写一篇文章，请参阅：Elasticsearch 的 easyjson 示例

1.3 ES 中的 JSONReader

esutil.JSONReader()方法将 struct、map 或任何其他可序列化对象转换为封装在 reader 中的 JSON，然后将其传递给WithBody()方法：

type Document struct{ Title string }
doc := Document{Title: "Test"}
es.Search(es.Search.WithBody(esutil.NewJSONReader(&doc)))

完整示例：

package main

import (
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/elastic/go-elasticsearch/v8/esapi"
    "github.com/elastic/go-elasticsearch/v8/esutil"
)

func init() {
    log.SetFlags(0)
}

func main() {
    var (
        res *esapi.Response
        err error
    )

    es, err := elasticsearch.NewDefaultClient()
    if err != nil {
        log.Fatalf("Error creating the client: %s", err)
    }

    doc := struct {
        Title string `json:"title"`
    }{Title: "Test"}

    res, err = es.Index("test", esutil.NewJSONReader(&doc), es.Index.WithRefresh("true"))
    if err != nil {
        log.Fatalf("Error getting response: %s", err)
    }

    log.Println(res)

    query := map[string]interface{}{
        "query": map[string]interface{}{
            "match": map[string]interface{}{
                "title": "test",
            },
        },
    }

    res, err = es.Search(
        es.Search.WithIndex("test"),
        es.Search.WithBody(esutil.NewJSONReader(&query)),
        es.Search.WithPretty(),
    )
    if err != nil {
        log.Fatalf("Error getting response: %s", err)
    }

    log.Println(res)
}

运行结果：

[201 Created] {"_index":"test","_type":"_doc","_id":"4l7aG3kBuWpKCVVn78cc","_version":1,"result":"created","forced_refresh":true,"_shards":{"total":2,"successful":1,"failed":0},"_seq_no":28,"_primary_term":4}
[200 OK] {
  "took" : 18,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 2.3671236,
    "hits" : [
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "4l7aG3kBuWpKCVVn78cc",
        "_score" : 2.3671236,
        "_source" : {
          "title" : "Test"
        }
      }
    ]
  }
}

1.4 几个 json 库的基准测试结果

BenchmarkEncode/Article_-_json-8               671839          1677 ns/op         768 B/op           5 allocs/op
BenchmarkEncode/Article_-_JSONReader-8         712545          1685 ns/op         824 B/op           7 allocs/op
BenchmarkEncode/Article_-_easyjson-8          1503753           802.0 ns/op         760 B/op           6 allocs/op
BenchmarkEncode/map_-_json-8                   934605          1279 ns/op         672 B/op          18 allocs/op
BenchmarkEncode/map_-_JSONReader-8             824247          1421 ns/op         728 B/op          20 allocs/op
BenchmarkDecode/Search_-_json-8                 46322         25893 ns/op        9258 B/op          75 allocs/op
BenchmarkDecode/Search_-_easyjson-8            103856         11344 ns/op       12635 B/op          70 allocs/op
BenchmarkDecode/Cluster_-_json_-_map-8          23635         50752 ns/op       31603 B/op         385 allocs/op
BenchmarkDecode/Cluster_-_json_-_stc-8          38974         30788 ns/op       15160 B/op          20 allocs/op
BenchmarkDecode/Cluster_-_gjson-8              909138          1354 ns/op         256 B/op           3 allocs/op

mailru/easyjson 和 tidwall/gjson 在不同场景下都比标准库有更好的性能。

六、第三方 http 库

本例演示如何使用fasthttp替换默认的net/http，并测试二者的性能。

1 示例代码

package http

import (
    "io/ioutil"
    "net/http"
    "strings"

    "github.com/valyala/fasthttp"
)

// Transport 用 fasthttp 实现 es 接口
type Transport struct{}

// RoundTrip 发送请求，返回响应或错误
func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
    freq := fasthttp.AcquireRequest()
    defer fasthttp.ReleaseRequest(freq)

    fres := fasthttp.AcquireResponse()
    defer fasthttp.ReleaseResponse(fres)

    t.copyRequest(freq, req)

    err := fasthttp.Do(freq, fres)
    if err != nil {
        return nil, err
    }

    res := &http.Response{Header: make(http.Header)}
    t.copyResponse(res, fres)

    return res, nil
}

// copyRequest 将 http 请求转换为 fasthttp 请求
func (t *Transport) copyRequest(dst *fasthttp.Request, src *http.Request) *fasthttp.Request {
    if src.Method == http.MethodGet && src.Body != nil {
        src.Method = http.MethodPost
    }

    dst.SetHost(src.Host)
    dst.SetRequestURI(src.URL.String())

    dst.Header.SetRequestURI(src.URL.String())
    dst.Header.SetMethod(src.Method)

    for k, vs := range src.Header {
        for _, v := range vs {
            dst.Header.Set(k, v)
        }
    }

    if src.Body != nil {
        dst.SetBodyStream(src.Body, -1)
    }

    return dst
}

// copyResponse 将 fasthttp 响应转换为 http 响应
func (t *Transport) copyResponse(dst *http.Response, src *fasthttp.Response) *http.Response {
    dst.StatusCode = src.StatusCode()

    src.Header.VisitAll(func(key, value []byte) {
        dst.Header.Set(string(key), string(value))
    })

    // 在响应被释放回响应池(fasthttp.ReleaseResponse)后，将 src.Body() 转换为字符串 Reader
    dst.Body = ioutil.NopCloser(strings.NewReader(string(src.Body())))

    return dst
}

2 基准测试

测试代码：

package http_test

import (
    "elasticsearch/fasthttp/http"
    "testing"

    "github.com/elastic/go-elasticsearch/v8"
)

func BenchmarkHTTPClient(b *testing.B) {
    b.ReportAllocs()

    client, err := elasticsearch.NewDefaultClient()
    if err != nil {
        b.Fatalf("ERROR: %s", err)
    }

    b.Run("Info()", func(b *testing.B) {
        b.ResetTimer()

        for i := 0; i < b.N; i++ {
            if res, err := client.Info(); err != nil {
                b.Errorf("Unexpected error when getting a response: %s", err)
            } else {
                res.Body.Close()
            }
        }
    })
}

func BenchmarkFastHTTPClient(b *testing.B) {
    b.ReportAllocs()

    client, err := elasticsearch.NewClient(
        elasticsearch.Config{Transport: &http.Transport{}},
    )
    if err != nil {
        b.Fatalf("ERROR: %s", err)
    }

    b.Run("Info()", func(b *testing.B) {
        b.ResetTimer()

        for i := 0; i < b.N; i++ {
            if res, err := client.Info(); err != nil {
                b.Errorf("Unexpected error when getting a response: %s", err)
            } else {
                res.Body.Close()
            }
        }
    })
}

结果：

...
BenchmarkHTTPClient/Info()-8                 6067       2438072 ns/op       15908 B/op         120 allocs/op
...
BenchmarkFastHTTPClient/Info()-8            14690        811282 ns/op        2325 B/op          27 allocs/op

http 标准库的性能在慢慢提高，但是仍然与 fasthttp 有着不小的差距。

七、检测仪

此示例演示了如何检测 es 客户端。

1 OpenCensus

使用 ochttp.Transport自动检测客户端调用，并将有关信息打印到终端。

package main

import (
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/fatih/color"

    "go.opencensus.io/plugin/ochttp"
    "go.opencensus.io/stats/view"
    "go.opencensus.io/tag"
    "go.opencensus.io/trace"
    "golang.org/x/crypto/ssh/terminal"
)

const count = 100

var (
    tWidth, _, _ = terminal.GetSize(int(os.Stdout.Fd()))

    faint   = color.New(color.Faint)
    bold    = color.New(color.Bold)
    boldRed = color.New(color.FgRed).Add(color.Bold)

    tagMethod, _ = tag.NewKey("method")
)

func init() {
    if tWidth < 0 {
        tWidth = 0
    }
}

// ConsoleExporter 将状态和追踪轨迹打印到终端
type ConsoleExporter struct{}

// ExportView 打印状态
func (e *ConsoleExporter) ExportView(vd *view.Data) {
    fmt.Println(strings.Repeat("─", tWidth))
    for _, row := range vd.Rows {
        faint.Print("█ ")
        fmt.Printf("%-17s ", strings.TrimPrefix(vd.View.Name, "opencensus.io/http/client/"))

        switch v := row.Data.(type) {
        case *view.DistributionData:
            bold.Printf("min=%-6.1f max=%-6.1f mean=%-6.1f", v.Min, v.Max, v.Mean)
        case *view.CountData:
            bold.Printf("count=%-3v", v.Value)
        case *view.SumData:
            bold.Printf("sum=%-3v", v.Value)
        case *view.LastValueData:
            bold.Printf("last=%-3v", v.Value)
        }
        faint.Print(" │ ")

        for _, tag := range row.Tags {
            faint.Printf("%-25s ", fmt.Sprintf("%v=%v", tag.Key.Name(), tag.Value))
        }
        fmt.Println()
    }
}

// ExportSpan 打印追踪轨迹
func (e *ConsoleExporter) ExportSpan(sd *trace.SpanData) {
    var c *color.Color
    if sd.Status.Code > 0 {
        c = color.New(color.FgRed)
    } else {
        c = color.New(color.FgGreen)
    }

    fmt.Println(strings.Repeat("─", tWidth))

    fmt.Printf(
        "░ %s %s %s\n",
        c.Sprint(sd.Status.Message),
        bold.Sprint(sd.Name),
        sd.EndTime.Sub(sd.StartTime).Round(time.Millisecond))

    faint.Printf("░ %x > %x\n", sd.SpanContext.TraceID[:], sd.SpanContext.SpanID[:])

    if len(sd.Attributes) > 0 {
        faint.Print("░ ")
        var keys []string
        for k := range sd.Attributes {
            keys = append(keys, k)
        }
        sort.Strings(keys)
        for i, k := range keys {
            faint.Printf("%s=%v", k, sd.Attributes[k])
            if i < len(keys)-1 {
                faint.Printf(" │ ")
            }
        }
    }
    fmt.Println()
}

func main() {
    log.SetFlags(0)
    start := time.Now()

    // Create new elasticsearch client ...
    //
    es, err := elasticsearch.NewClient(
        elasticsearch.Config{
            // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            // ... 使用"ochttp" 封装检测仪
            Transport: &ochttp.Transport{},
            // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        })
    if err != nil {
        log.Fatalf("ERROR: %s", err)
    }

    // 创建 done 管道
    //
    done := make(chan os.Signal)
    signal.Notify(done, os.Interrupt)

    // 创建刻点
    //
    tickers := struct {
        Info   *time.Ticker
        Index  *time.Ticker
        Health *time.Ticker
        Search *time.Ticker
    }{
        Info:   time.NewTicker(time.Second),
        Index:  time.NewTicker(500 * time.Millisecond),
        Health: time.NewTicker(5 * time.Second),
        Search: time.NewTicker(10 * time.Second),
    }
    defer tickers.Info.Stop()
    defer tickers.Index.Stop()
    defer tickers.Health.Stop()
    defer tickers.Search.Stop()

    // 使用 ochttp 插件注册视图
    //
    if err := view.Register(
        ochttp.ClientRoundtripLatencyDistribution,
        ochttp.ClientCompletedCount,
    ); err != nil {
        log.Fatalf("ERROR: %s", err)
    }

    // 一段时间向 STDOUT 报告一次视图
    //
    view.SetReportingPeriod(5 * time.Second)
    view.RegisterExporter(&ConsoleExporter{})

    // 向 STDOUT 报告一部分轨迹
    //
    trace.ApplyConfig(trace.Config{DefaultSampler: trace.ProbabilitySampler(0.5)})
    trace.RegisterExporter(&ConsoleExporter{})

    // 初始化上下文
    //
    ctx, _ := tag.New(context.Background(), tag.Upsert(tagMethod, "main"))

    // 调用 api
    //
    for {
        select {
        case <-done:
            fmt.Print("\n")
            fmt.Println(strings.Repeat("━", tWidth))
            faint.Printf("Finished in %s\n\n", time.Now().Sub(start).Truncate(time.Second))
            return

        // -> Info
        //
        case <-tickers.Info.C:
            res, err := es.Info(es.Info.WithContext(ctx))
            if err != nil {
                boldRed.Printf("Error getting response: %s\n", err)
            } else {
                res.Body.Close()
            }

        // -> Index
        //
        case t := <-tickers.Index.C:
            // Artificially fail some requests...
            var body io.Reader
            if t.Second()%4 == 0 {
                body = strings.NewReader(``)
            } else {
                body = strings.NewReader(`{"timestamp":"` + t.Format(time.RFC3339) + `"}`)
            }

            res, err := es.Index("test", body, es.Index.WithContext(ctx))
            if err != nil {
                boldRed.Printf("Error getting response: %s\n", err)
            } else {
                res.Body.Close()
            }

        // -> Health
        //
        case <-tickers.Health.C:
            res, err := es.Cluster.Health(
                es.Cluster.Health.WithLevel("indices"),
                es.Cluster.Health.WithContext(ctx),
            )
            if err != nil {
                boldRed.Printf("Error getting response: %s\n", err)
            } else {
                res.Body.Close()
            }

        // -> Search
        //
        case <-tickers.Search.C:
            res, err := es.Search(
                es.Search.WithIndex("test"),
                es.Search.WithSort("timestamp:desc"),
                es.Search.WithSize(1),
                es.Search.WithContext(ctx),
            )
            if err != nil {
                boldRed.Printf("Error getting response: %s\n", err)
            } else {
                res.Body.Close()
            }
        }
    }
}

2 Elastic APM

使用Go agent for Elastic APM检测客户端：

• 配置多种类型的事务
• 在每个事务中创建自定义跨度
• 报告错误

使用 docker 示例。

2.1 docker-compose 配置文件

文件名：elasticstack.yml。

version: "3.2"

services:
  # --- Application -----------------------------------------------------------
  application:
    container_name: application
    build: .
    networks: ["elasticstack"]
    depends_on:
      - elasticsearch
      - kibana
      - apm-server

  # --- Elasticsearch ---------------------------------------------------------
  elasticsearch:
    image: elasticsearch:7.12.1
    container_name: elasticsearch
    volumes:
      - es_data:/usr/share/elasticsearch/data:delegated
    networks: ["elasticstack"]
    environment:
      - "cluster.name=go-elasticsearch-instrumentation"
      - "cluster.routing.allocation.disk.threshold_enabled=false"
      - "discovery.type=single-node"
      - "bootstrap.memory_lock=true"
      - "xpack.security.enabled=false"
      - "ES_JAVA_OPTS=-Xms1g -Xmx1g"
    expose:
      - "9200"
    ulimits:
      memlock: -1
      nproc: 65535
      nofile: 65535
    healthcheck:
      test: curl --max-time 60 --retry 60 --retry-delay 1 --retry-connrefused --show-error --silent http://localhost:9200

  # --- Kibana ----------------------------------------------------------------
  kibana:
    image: kibana:7.12.1
    container_name: kibana
    networks: ["elasticstack"]
    environment:
      - "ELASTICSEARCH_URL=http://elasticsearch:9200"
    ports:
      - "5601:5601"
    depends_on: ["elasticsearch"]
    healthcheck:
      test: curl --max-time 60 --retry 60 --retry-delay 1 --retry-connrefused --show-error --silent http://localhost:5601

  # --- APM Server ------------------------------------------------------------
  apm-server:
    image: elastic/apm-server:7.12.1
    container_name: apm_server
    networks: ["elasticstack"]
    command: >
      ./apm-server run -e \
        -E output.elasticsearch.hosts=http://elasticsearch:9200 \
        -E setup.kibana.host=http://kibana:5601
    expose:
      - "8200"
    depends_on: ["elasticsearch", "kibana"]
    healthcheck:
      test: curl --max-time 60 --retry 60 --retry-delay 1 --retry-connrefused --show-error --silent http://localhost:8200/healthcheck

networks:
  elasticstack:

volumes:
  es_data:

2.2 Dockerfile

FROM golang:1.16.3

RUN echo 'deb http://mirrors.aliyun.com/debian/ buster main non-free contrib\n\
deb http://mirrors.aliyun.com/debian-security buster/updates main\n\
deb http://mirrors.aliyun.com/debian/ buster-updates main non-free contrib\n\
deb http://mirrors.aliyun.com/debian/ buster-backports main non-free contrib\n'\
> /etc/apt/sources.list
RUN apt-get update && apt-get install -y gcc g++ ca-certificates make curl git jq

WORKDIR /go-elasticsearch-demo-instrumentation

RUN go env -w GO111MODULE=on && go env -w GOPROXY=https://goproxy.cn,direct

COPY go.mod .
RUN go mod download

ENV TERM xterm-256color

ENV ELASTICSEARCH_URL=${ELASTICSEARCH_URL:-http://elasticsearch:9200}

ENV ELASTIC_APM_SERVER_URL=${ELASTIC_APM_SERVER_URL:-http://apm_server:8200}
ENV ELASTIC_APM_SERVICE_NAME=go-elasticsearch-demo-instrumentation
ENV ELASTIC_APM_METRICS_INTERVAL=5s
ENV ELASTIC_APM_LOG_FILE=stderr
ENV ELASTIC_APM_LOG_LEVEL=debug

COPY apmelasticsearch.go opencensus.go ./

CMD go run apmelasticsearch.go

2.3 运行

elasticstack.yml 和 Dockfile 放在同一目录。

运行：

docker-compose --file elasticstack.yml up --build

删除示例 docker 文件：

docker-compose --file elasticstack.yml down --remove-orphans --volumes

八、扩展

此例演示如何扩展客户端，以便调用自定义 API。

main.go示例中定义了嵌入到常规客户端的自定义类型，添加一个实现了Example()方法的Custom命名空间。

package main

import (
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/elastic/go-elasticsearch/v8/esapi"
    "github.com/elastic/go-elasticsearch/v8/estransport"
)

const port = "9209"

// ExtendedClient 包括常规 api 和自定义 api
type ExtendedClient struct {
    *elasticsearch.Client
    Custom *ExtendedAPI
}

// ExtendedAPI 自定义 api
type ExtendedAPI struct {
    *elasticsearch.Client
}

// Example 调用自定义 restful api，"GET /_cat/example"
func (e *ExtendedAPI) Example() (*esapi.Response, error) {
    req, _ := http.NewRequest("GET", "/_cat/example", nil)

    res, err := e.Perform(req)
    if err != nil {
        return nil, err
    }

    return &esapi.Response{StatusCode: res.StatusCode, Body: res.Body, Header: res.Header}, nil
}

func main() {
    log.SetFlags(0)

    started := make(chan bool)

    // 启动代理服务
    go startServer(started)

    ec, err := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:" + port},
        Logger:    &estransport.ColorLogger{Output: os.Stdout, EnableRequestBody: true, EnableResponseBody: true},
    })
    if err != nil {
        log.Fatalf("Error creating the client: %s", err)
    }

    es := ExtendedClient{
        Client: ec,
        Custom: &ExtendedAPI{ec},
    }
    <-started

    // 调用常规 api
    es.Cat.Health()

    // 调用自定义 api
    es.Custom.Example()

}

func startServer(started chan<- bool) {
    proxy := httputil.NewSingleHostReverseProxy(&url.URL{Scheme: "http", Host: "localhost:9200"})

    // 在"GET /_cat/example"上以自定义内容响应，将其他请求代理到 es
    //
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if r.Method == "GET" && r.URL.Path == "/_cat/example" {
            io.WriteString(w, "Hello from Cat Example action")
            return
        }
        proxy.ServeHTTP(w, r)
    })

    ln, err := net.Listen("tcp", "localhost:"+port)
    if err != nil {
        log.Fatalf("Unable to start server: %s", err)
    }

    go http.Serve(ln, nil)
    started <- true
}

结果：

九、安全

本例演示如何通过用自定义证书使用 TLS (传输层安全) 来加密和验证与 ES 集群的通信。

1 为集群创建证书

创建证书的命令如下：

OUTPUT="/certificates/bundle.zip"
if [[ -f $$OUTPUT ]]; then
  echo "Certificates already present in [.$$OUTPUT]"; exit 1;
else
  yum install -y -q -e 0 unzip tree;
  bin/elasticsearch-certutil cert \
    --pem \
    --days 365 \
    --keep-ca-key \
    --in config/certificates/certificates-config.yml \
    --out $$OUTPUT;
  unzip -q $$OUTPUT -d /certificates;
  chown -R 1000:0 /certificates; echo;
  tree /certificates;
fi;

命令中用到的certificates-config.yml内容如下：

instances:
  - name: elasticsearch
    ip:  [0.0.0.0, 127.0.0.1]
    dns: ["localhost", "example_elasticsearch_1", "example_elasticsearch_2", "example_elasticsearch_3"]

既然是示例，创建一个即用即毁的环境是很有必要的，所以使用一个 docker 容器运行上面的命令是最好的选择。

docker-compose 文件：

version: "3.7"

services:
  create_certificates:
    image: elasticsearch:7.12.1
    container_name: certificates_generator
    user: root
    working_dir: /usr/share/elasticsearch
    command: >
      bash -c '
        OUTPUT="/certificates/bundle.zip"
        if [[ -f $$OUTPUT ]]; then
          echo "Certificates already present in [.$$OUTPUT]"; exit 1;
        else
          yum install -y -q -e 0 unzip tree;
          bin/elasticsearch-certutil cert \
            --pem \
            --days 365 \
            --keep-ca-key \
            --in config/certificates/certificates-config.yml \
            --out $$OUTPUT;
          unzip -q $$OUTPUT -d /certificates;
          chown -R 1000:0 /certificates; echo;
          tree /certificates;
        fi;
      '
    volumes:
      - ./certificates:/certificates
      - ./certificates-config.yml:/usr/share/elasticsearch/config/certificates/certificates-config.yml

运行 docker 容器：

docker-compose --file certificates-create.yml run --rm create_certificates

运行完成后，当前目录中就会生成一个包含证书的certificates文件夹。

现在有了证书，下面就可以创建一个开启安全认证的集群。

docker-compose 文件：

version: "3.7"

services:
  elasticsearch:
    image: elasticsearch:${ELASTIC_VERSION}
    volumes:
      - es-data:/usr/share/elasticsearch/data
      - ./certificates:/usr/share/elasticsearch/config/certificates/
    networks:
      - elasticstack
    ports:
      - 9200:9200
    environment:
      - node.name=example_elasticsearch_1
      - cluster.name=golang-example-security
      - cluster.initial_master_nodes=example_elasticsearch_1
      - discovery.seed_hosts=example_elasticsearch_1
      - bootstrap.memory_lock=true
      - network.host=example_elasticsearch_1,_local_
      - network.publish_host=example_elasticsearch_1
      - ES_JAVA_OPTS=-Xms1G -Xmx1G -Des.transport.cname_in_publish_address=true
      # Security & TLS
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=/usr/share/elasticsearch/config/certificates/elasticsearch/elasticsearch.key
      - xpack.security.http.ssl.certificate=/usr/share/elasticsearch/config/certificates/elasticsearch/elasticsearch.crt
      - xpack.security.http.ssl.certificate_authorities=/usr/share/elasticsearch/config/certificates/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.security.transport.ssl.key=/usr/share/elasticsearch/config/certificates/elasticsearch/elasticsearch.key
      - xpack.security.transport.ssl.certificate=/usr/share/elasticsearch/config/certificates/elasticsearch/elasticsearch.crt
      - xpack.security.transport.ssl.certificate_authorities=/usr/share/elasticsearch/config/certificates/ca/ca.crt
    ulimits: { nofile: { soft: 262144, hard: 262144 }, memlock: -1 }
    healthcheck:
      test: curl --cacert /usr/share/elasticsearch/config/certificates/ca/ca.crt --max-time 120 --retry 120 --retry-delay 1 --show-error --silent https://elastic:${ELASTIC_PASSWORD}@localhost:9200

networks:
  elasticstack: { labels: { elasticstack.description: "Network for the Elastic Stack" }}

volumes:
  es-data: { labels: { elasticstack.description: "Elasticsearch data" }}

运行集群：

docker-compose --file elasticsearch-cluster.yml up --remove-orphans --detach

用证书访问配合账号密码访问：

curl --cacert certificates/ca/ca.crt https://elastic:elastic@localhost:9200

会得到正确响应。

2 使用 Go 客户端安全访问

2.1 使用客户端配置中的证书字段

先从文件中读取证书内容，然后将证书放到客户端配置中：

// --> 从文件中读取证书
cert, _ := ioutil.ReadFile(*cacert)

es, _ := elasticsearch.NewClient(
    elasticsearch.Config{
        // ...

        // --> 将证书放到配置中
        CACert: cert,
    })

2.2 根据证书创建自定义传输

cert, _ := ioutil.ReadFile(*cacert)

// 复制默认传输
tp := http.DefaultTransport.(*http.Transport).Clone()

// 初始化一个根证书颁发机构
tp.TLSClientConfig.RootCAs, _ = x509.SystemCertPool()

// 添加自定义证书颁发机构
tp.TLSClientConfig.RootCAs.AppendCertsFromPEM(cert)

es, _ := elasticsearch.NewClient(
  elasticsearch.Config{
    Addresses: []string{"https://localhost:9200"},
    Username:  "elastic",
    Password:  *password,

    // --> 将自定义传输添加到客户端配置中
    //
    Transport: tp,
  },
)

十、示例应用

爬取掘金热门推荐的页面的信息保存到 es 中，并进行查询。

示例项目地址：thep0y/juejin-hot-es-example

查询时使用命令行进行，示例项目的命令如下：

juejin allows you to index and search hot-recommended article's titles

Usage:
  juejin [command]

Available Commands:
  help        Help about any command
  index       Index juejin hot-recommended articles into Elasticsearch
  search      Search juejin hot recommended articles

Flags:
  -h, --help           help for juejin
  -i, --index string   Index name (default "juejin")

Use "juejin [command] --help" for more information about a command.

可选参数为index和search。

其中index也有可选命令：

      --pages int   The count of pages you want to crawl (default 5)
      --setup       Create Elasticsearch index

本项目使用的是本地 es ，推荐用 docker 创建，es 中需要安装 ik 中文分词插件。

1 创建索引

go run main.go index --setup

默认会根据项目中指定的 mapping 创建索引，并爬取存储 5 页、共 100 条信息。

结果如下所示：

8:10PM INF Creating index with mapping
8:10PM INF Starting the crawl with 0 workers at 0 offset
8:10PM INF Stored doc Article ID=6957974706943164447 title="算法篇01、排序算法"
8:10PM INF Stored doc Article ID=6953868764362309639 title="如何处理浏览器的断网情况？"
...
8:10PM INF Skipping existing doc ID=6957726578692341791
8:10PM INF Skipping existing doc ID=6957925118429364255
8:10PM INF Skipping existing doc ID=6953868764362309639
8:10PM INF Skipping existing doc ID=6957981912669519903
8:10PM INF Skipping existing doc ID=6953059119561441287
8:10PM INF Skipping existing doc ID=6955336007839383588
...
8:10PM INF Stored doc Article ID=6957930535574306847 title="Node系列-阻塞和非阻塞的理解"
8:10PM INF Stored doc Article ID=6956602138201948196 title="《前端领域的转译打包工具链》上篇"
8:10PM INF Stored doc Article ID=6957982556885090312 title="JS篇：事件流"

终端结果截图：

因为每页有 20 条，共爬 5 页，所以理论上应存储 100 条信息，但其中可能会存在几条重复信息，所以最后保存时可能会小于 100 条。

2 爬取 10 页

go run main.go index --pages 10

运行这条命令时，不会再创建索引，而是直接开始爬虫，因为只是示例项目，所以没有增加起始页和最终页的选择，只提供最终页码作为可选参数。

运行结果与上小节基本相同：

3 查询

查询时，使用的是词组查询，中文更适合使用词组查询，不然每个查询词被拆分成单字查询，结果一般不是我们想要的。

go run main.go search 前端

查询到的结果中会将查询词高亮显示：