Go-Elasticsearch

Elasticsearch ist eine verteilte Suchmaschine, die auf Lucene basiert. In diesem Artikel wird die Verwendung von Elasticsearch mit Go vorgestellt.

Installation

Zuerst muss der Elasticsearch-Client installiert werden.

go get github.com/elastic/go-elasticsearch/v8

Verbindung herstellen

package main

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

func main() {
    cfg := elasticsearch.Config{
        Addresses: []string{
            "http://localhost:9200",
        },
        Username: "elastic",
        Password: "password",
    }

    es, err := elasticsearch.NewClient(cfg)
    if err != nil {
        log.Fatalf("Fehler beim Erstellen des Clients: %s", err)
    }

    res, err := es.Info()
    if err != nil {
        log.Fatalf("Fehler beim Abrufen der Antwort: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Elasticsearch-Client: %s", res.String())
}

Dokument indizieren

package main

import (
    "bytes"
    "encoding/json"
    "github.com/elastic/go-elasticsearch/v8"
    "log"
)

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

    doc := map[string]interface{}{
        "title":   "Go Programming",
        "content": "Go ist eine Programmiersprache von Google.",
        "author":  "Alice",
    }

    var buf bytes.Buffer
    json.NewEncoder(&buf).Encode(doc)

    res, err := es.Index("articles", &buf)
    if err != nil {
        log.Fatalf("Fehler beim Indizieren: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Dokument indiziert: %s", res.String())
}

Dokument abrufen

package main

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

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

    res, err := es.Get("articles", "1")
    if err != nil {
        log.Fatalf("Fehler beim Abrufen: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Dokument abgerufen: %s", res.String())
}

Dokument aktualisieren

package main

import (
    "bytes"
    "encoding/json"
    "github.com/elastic/go-elasticsearch/v8"
    "log"
)

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

    doc := map[string]interface{}{
        "doc": map[string]interface{}{
            "title": "Go Programming Updated",
        },
    }

    var buf bytes.Buffer
    json.NewEncoder(&buf).Encode(doc)

    res, err := es.Update("articles", "1", &buf)
    if err != nil {
        log.Fatalf("Fehler beim Aktualisieren: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Dokument aktualisiert: %s", res.String())
}

Dokument löschen

package main

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

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

    res, err := es.Delete("articles", "1")
    if err != nil {
        log.Fatalf("Fehler beim Löschen: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Dokument gelöscht: %s", res.String())
}

Suche

package main

import (
    "bytes"
    "encoding/json"
    "github.com/elastic/go-elasticsearch/v8"
    "log"
)

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

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

    var buf bytes.Buffer
    json.NewEncoder(&buf).Encode(query)

    res, err := es.Search(
        es.Search.WithIndex("articles"),
        es.Search.WithBody(&buf),
    )
    if err != nil {
        log.Fatalf("Fehler bei der Suche: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Suche abgeschlossen: %s", res.String())
}

Bulk-Operationen

package main

import (
    "bytes"
    "encoding/json"
    "github.com/elastic/go-elasticsearch/v8"
    "log"
)

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

    var buf bytes.Buffer

    // Index-Operation
    meta := []byte(`{"index":{"_index":"articles","_id":"1"}}`+"\n")
    buf.Write(meta)

    doc := map[string]interface{}{
        "title":   "Article 1",
        "content": "Content 1",
    }
    json.NewEncoder(&buf).Encode(doc)

    // Weitere Operationen...

    res, err := es.Bulk(&buf)
    if err != nil {
        log.Fatalf("Fehler bei Bulk-Operation: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Bulk-Operation abgeschlossen: %s", res.String())
}

Index erstellen

package main

import (
    "bytes"
    "encoding/json"
    "github.com/elastic/go-elasticsearch/v8"
    "log"
)

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

    mapping := map[string]interface{}{
        "mappings": map[string]interface{}{
            "properties": map[string]interface{}{
                "title": map[string]interface{}{
                    "type": "text",
                },
                "content": map[string]interface{}{
                    "type": "text",
                },
                "author": map[string]interface{}{
                    "type": "keyword",
                },
            },
        },
    }

    var buf bytes.Buffer
    json.NewEncoder(&buf).Encode(mapping)

    res, err := es.Indices.Create("articles", es.Indices.Create.WithBody(&buf))
    if err != nil {
        log.Fatalf("Fehler beim Erstellen des Index: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Index erstellt: %s", res.String())
}

Index löschen

package main

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

func main() {
    es, _ := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{"http://localhost:9200"},
    })

    res, err := es.Indices.Delete([]string{"articles"})
    if err != nil {
        log.Fatalf("Fehler beim Löschen des Index: %s", err)
    }
    defer res.Body.Close()

    log.Printf("Index gelöscht: %s", res.String())
}