So implementieren Sie Elasticsearch in Go

Heute werde ich Ihnen zeigen, wie Sie Elasticsearch in Go implementieren.

Aber vorher werde ich natürlich eine kleine Einführung in Elasticsearch geben.

Wenn Sie bereits ein grundlegendes Verständnis von Elasticsearch erworben haben, können Sie mit dem nächsten Teil fortfahren.

Elasticsearch

Elasticsearch hat in letzter Zeit eine große Popularität erlangt. Die Suche in einer relationalen Datenbank hat immer Probleme mit der Skalierbarkeit und Leistung.

Elasticsearch ist eine NoSQL-Datenbank, die diese Probleme sehr erfolgreich gelöst hat. Es bietet eine hervorragende Skalierbarkeit und Leistung, und eines der wichtigsten Merkmale ist das Bewertungssystem, das eine große Flexibilität bei den Suchergebnissen ermöglicht. Immerhin heißt es nicht ohne Grund Elastische Suche!

Elasticsearch installieren

Zunächst müssen Sie Elasticsearch auf Ihrem lokalen Computer installieren. Sie können auf ihre Website gehen und die Installationsanleitung dafür erhalten. Zum Zeitpunkt des Schreibens dieses Artikels verwende ich Elasticsearch mit der Versionsnummer 7.4.2.

Elasticsearch hat viele Änderungen an ihren Versionen vorgenommen, unter anderem das Entfernen des Mapping-Typs. Erwarten Sie also nicht, dass dies vollständig funktioniert, wenn Sie eine andere Version von Elasticsearch verwenden.

Vergessen Sie nach Abschluss Ihrer Installation nicht, Ihren Elasticsearch-Dienst auszuführen, der in der Installationsanleitung deutlich angegeben ist (kurz für Linux ./bin/elasticsearch).

Stellen Sie sicher, dass Ihre Elasticsearch ausgeführt wird, indem Sie Port 9200 auf Ihrem lokalen Computer anfordern.

ERHALTEN localhost:9200

Wenn Sie es treffen, sollte etwas wie unten angezeigt werden.

{ "name": "204371", "cluster_name": "elasticsearch", "cluster_uuid": "8Aa0PznuR1msDL9-PYsNQg", "version": { "number": "7.4.2", "build_flavor": "default", "build_type": "tar", "build_hash": "2f90bbf7b93631e52bafb59b3b049cb44ec25e96", "build_date": "2019-10-28T20:40:44.881551Z", "build_snapshot": false, "lucene_version": "8.2.0", "minimum_wire_compatibility_version": "6.8.0", "minimum_index_compatibility_version": "6.0.0-beta1" }, "tagline": "You Know, for Search" }

Wenn es richtig angezeigt wird, dann herzlichen Glückwunsch! Sie haben Ihren Elasticsearch-Dienst erfolgreich auf Ihrem lokalen Computer ausgeführt. Gönnen Sie sich einen Klaps und trinken Sie eine Tasse Kaffee, da der Tag noch jung ist.

Machen Sie Ihren ersten Index

In Elasticsearch ähnelt der Index einer Datenbank. Während zuvor in der Elasticsearch eine Tabelle namens type vorhanden war. Da der Typ in der aktuellen Version entfernt wurde, gibt es jetzt nur noch einen Index.

Jetzt verwirrt? Sei nicht. Kurz gesagt, denken Sie nur, dass Sie nur einen Index benötigen, und anschließend müssen Sie nur noch Ihre Daten in Elasticsearch einfügen.

Jetzt erstellen wir einen Index mit dem Namen, studentsindem wir die folgende Abfrage ausführen.

STELLEN localhost/9200/students

{ "settings": { "number_of_shards": 1, "number_of_replicas": 1 }, "mappings": { "properties": { "name": { "type": "text" }, "age": { "type": "integer" }, "average_score": { "type": "float" } } } }

Wenn nichts schief geht, sollte es dies zurückgeben.

{ "acknowledged": true, "shards_acknowledged": true } 

Ihr Index sollte erstellt werden. Jetzt fahren wir mit unserem nächsten Schritt fort: Herumspielen mit unserem Elasticsearch-Index.

Füllen Sie Ihre Elasticsearch

Zunächst füllen wir unseren Elasticsearch-Index mit Dokumenten. Wenn Sie mit dieser Definition nicht vertraut sind, wissen Sie einfach, dass sie Zeilen in einer Datenbank sehr ähnlich ist.

In einer NoSQL-Datenbank kann jedes Dokument unterschiedliche Felder enthalten, die nicht mit dem Schema übereinstimmen.

Aber machen wir das nicht - konstruieren wir unsere Spalte mit einem Schema, das wir zuvor definiert haben. Mit der vorherigen API können Sie das Dokument in Ihren Index einfügen.

POST localhost:9200/students/doc

{ "name":"Alice", "age":17, "average_score":81.1 } 

Ihre Elasticsearch sollte jetzt ein Dokument haben. Wir müssen mehrere weitere Daten in unsere Elasticsearch einfügen. Und natürlich werden wir unsere Studentendaten nicht einzeln einfügen - das wäre ein ziemlicher Aufwand!

Elasticsearch hat speziell eine Bulk-API vorbereitet, um mehrere Anforderungen gleichzeitig zu senden. Verwenden Sie dies, um mehrere Daten gleichzeitig einzufügen.

POST /students/_bulk

{ "index":{"_index": "students" } } { "name":"john doe","age":18, "average_score":77.7 } { "index":{"_index": "students" } } { "name":"bob","age":16, "average_score":65.5 } { "index":{"_index": "students" } } { "name":"mary doe","age":18, "average_score":97.7 } { "index":{"_index": "students" } } { "name":"eve","age":15, "average_score":98.9 }

Fragen wir nach den Daten

Wir haben unsere Elasticsearch endlich mit mehreren weiteren Schülerdaten gefüllt. Lassen Sie uns nun das tun, wofür Elasticsearch bekannt ist: Wir werden versuchen, unsere Elasticsearch nach den Daten zu durchsuchen, die wir gerade eingefügt haben.

Elasticsearch unterstützt viele Arten von Suchmechanismen. In diesem Beispiel verwenden wir jedoch eine einfache übereinstimmende Abfrage.

Beginnen wir unsere Suche mit dieser API:

POST localhost:9200/_search

{ "query" : { "match" : { "name" : "doe" } } } 

Sie erhalten Ihre Antwort zusammen mit den Daten der Schüler zurück, die mit Ihrer entsprechenden Anfrage übereinstimmen. Jetzt sind Sie offiziell ein Suchingenieur!

{ "took": 608, "timed_out": false, "_shards": { "total": 1, "successful": 1, "skipped": 0, "failed": 0 }, "hits": { "total": { "value": 2, "relation": "eq" }, "max_score": 0.74487394, "hits": [ { "_index": "students", "_type": "_doc", "_id": "rgpef24BTFuh7kXolTpo", "_score": 0.74487394, "_source": { "name": "john doe", "age": 18, "average_score": 77.7 } }, { "_index": "students", "_type": "_doc", "_id": "sApef24BTFuh7kXolTpo", "_score": 0.74487394, "_source": { "name": "mary doe", "age": 18, "average_score": 97.7 } } ] } }

Jetzt können wir loslegen!

If you have reached this part, you should have grasped the very minimum concepts of using Elasticsearch. Now, we are going to implement Elasticsearch in Go.

A very primitive way of implementing Elasticsearch is that you can keep doing http requests into your Elasticsearch IP. But we are not going to do that.

I found this very helpful library for implementing Elasticsearch in Go. You should install that library before you proceed in your Go modules.

Make your struct

First of all, you will definitely need to make a struct for your Model. In this example, we are going to use the same modeling as in our previous example which in this case is the Student struct.

package main type Student struct { Name string `json:"name"` Age int64 `json:"age"` AverageScore float64 `json:"average_score"` }

Making a Client Connection

Now, let's make a function that'll allow us to initialize our ES Client connection.

If you have a running instance of Elasticsearch outside of your localhost, you can simply change the part inside SetURL.

func GetESClient() (*elastic.Client, error) { client, err := elastic.NewClient(elastic.SetURL("//localhost:9200"), elastic.SetSniff(false), elastic.SetHealthcheck(false)) fmt.Println("ES initialized...") return client, err }

Data Insertion

After that, the first thing we can do is try to insert our data into Elasticsearch via Go. We will be making a model of Student and inserting it into our Elasticsearch client.

package main import ( "context" "encoding/json" "fmt" elastic "gopkg.in/olivere/elastic.v7" ) func main() { ctx := context.Background() esclient, err := GetESClient() if err != nil { fmt.Println("Error initializing : ", err) panic("Client fail ") } //creating student object newStudent := Student{ Name: "Gopher doe", Age: 10, AverageScore: 99.9, } dataJSON, err := json.Marshal(newStudent) js := string(dataJSON) ind, err := esclient.Index(). Index("students"). BodyJson(js). Do(ctx) if err != nil { panic(err) } fmt.Println("[Elastic][InsertProduct]Insertion Successful") }

Querying our Data

Finally, we can do some searching. The below code might look a bit complex. But rest assured, it will make more sense to you after you go through it carefully. I will be using a basic matching query in the below example.

package main import ( "context" "encoding/json" "fmt" elastic "gopkg.in/olivere/elastic.v7" ) func main() { ctx := context.Background() esclient, err := GetESClient() if err != nil { fmt.Println("Error initializing : ", err) panic("Client fail ") } var students []Student searchSource := elastic.NewSearchSource() searchSource.Query(elastic.NewMatchQuery("name", "Doe")) /* this block will basically print out the es query */ queryStr, err1 := searchSource.Source() queryJs, err2 := json.Marshal(queryStr) if err1 != nil || err2 != nil { fmt.Println("[esclient][GetResponse]err during query marshal=", err1, err2) } fmt.Println("[esclient]Final ESQuery=\n", string(queryJs)) /* until this block */ searchService := esclient.Search().Index("students").SearchSource(searchSource) searchResult, err := searchService.Do(ctx) if err != nil { fmt.Println("[ProductsES][GetPIds]Error=", err) return } for _, hit := range searchResult.Hits.Hits { var student Student err := json.Unmarshal(hit.Source, &student) if err != nil { fmt.Println("[Getting Students][Unmarshal] Err=", err) } students = append(students, student) } if err != nil { fmt.Println("Fetching student fail: ", err) } else { for _, s := range students { fmt.Printf("Student found Name: %s, Age: %d, Score: %f \n", s.Name, s.Age, s.AverageScore) } } }

The query should be printed out like this:

ES initialized... [esclient]Final ESQuery= {"query":{"match":{"name":{"query":"Doe"}}}}

And yes that query is what will be posted into the Elasticsearch.

The result of your query should also come out like this if you have followed my example since the very start:

Student found Name: john doe, Age: 18, Score: 77.700000 Student found Name: mary doe, Age: 18, Score: 97.700000 Student found Name: Gopher doe, Age: 10, Score: 99.900000 

And there you go!

Das ist das Ende meines Tutorials zur Implementierung von Elasticsearch in Go. Ich hoffe, ich habe die grundlegenden Teile der Verwendung von Elasticsearch in Go behandelt.

Um weitere Informationen zu diesem Thema zu erhalten, sollten Sie sich mit Query DSL und Function Scoring in Elasticsearch befassen, was meiner Meinung nach eines der besten Dinge bei Elasticsearch ist.

Und ärgern Sie sich nicht, die in diesem Beispiel verwendete Bibliothek unterstützt auch viele Elasticsearch-Funktionen, sogar die Funktionsbewertungsabfrage in Elasticsearch.

Vielen Dank für das Lesen meines Artikels! Ich hoffe, dass es nützlich ist und Ihnen beim Einstieg in Elasticsearch helfen kann.

Höre nie auf zu lernen; Das Wissen verdoppelt sich alle vierzehn Monate. ~ Anthony J.D'Angelo