Go client

The OpenSearch Go client lets you connect your Go application with the data in your OpenSearch cluster.

Setup

If you’re creating a new project:

  1. go mod init

To add the client to your project, import it like any other module:

  1. go get github.com/opensearch-project/opensearch-go

Sample code

This sample code creates a client, adds an index with non-default settings, inserts a document, searches for the document, deletes the document, and finally deletes the index:

  1. package main
  2. import (
  3.     "os"
  4.     "context"
  5.     "crypto/tls"
  6.     "fmt"
  7.     opensearch "github.com/opensearch-project/opensearch-go"
  8.     opensearchapi "github.com/opensearch-project/opensearch-go/opensearchapi"
  9.     "net/http"
  10.     "strings"
  11. )
  12. const IndexName = "go-test-index1"
  13. func main() {
  14.     // Initialize the client with SSL/TLS enabled.
  15.     client, err := opensearch.NewClient(opensearch.Config{
  16.         Transport: &http.Transport{
  17.             TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
  18.         },
  19.         Addresses: []string{"https://localhost:9200"},
  20.         Username:  "admin", // For testing only. Don't store credentials in code.
  21.         Password:  "admin",
  22.     })
  23.     if err != nil {
  24.         fmt.Println("cannot initialize", err)
  25.         os.Exit(1)
  26.     }
  28.     // Print OpenSearch version information on console.
  29.     fmt.Println(client.Info())
  31.     // Define index mapping.
  32.     mapping := strings.NewReader(`{
  33.      'settings': {
  34.        'index': {
  35.             'number_of_shards': 4
  36.             }
  37.           }
  38.      }`)
  40.     // Create an index with non-default settings.
  41.     res := opensearchapi.CreateRequest{
  42.         Index: IndexName,
  43.         Body:  mapping,
  44.     }
  45.     fmt.Println("creating index", res)
  47.     // Add a document to the index.
  48.     document := strings.NewReader(`{
  49.         "title": "Moneyball",
  50.         "director": "Bennett Miller",
  51.         "year": "2011"
  52.     }`)
  54.     docId := "1"
  55.     req := opensearchapi.IndexRequest{
  56.         Index:      IndexName,
  57.         DocumentID: docId,
  58.         Body:       document,
  59.     }
  60.     insertResponse, err := req.Do(context.Background(), client)
  61.     if err != nil {
  62.         fmt.Println("failed to insert document ", err)
  63.         os.Exit(1)
  64.     }
  65.     fmt.Println(insertResponse)
  67.     // Search for the document.
  68.     content := strings.NewReader(`{
  69.        "size": 5,
  70.        "query": {
  71.            "multi_match": {
  72.            "query": "miller",
  73.            "fields": ["title^2", "director"]
  74.            }
  75.       }
  76.     }`)
  78.     search := opensearchapi.SearchRequest{
  79.         Body: content,
  80.     }
  82.     searchResponse, err := search.Do(context.Background(), client)
  83.     if err != nil {
  84.         fmt.Println("failed to search document ", err)
  85.         os.Exit(1)
  86.     }
  87.     fmt.Println(searchResponse)
  89.     // Delete the document.
  90.     delete := opensearchapi.DeleteRequest{
  91.         Index:      IndexName,
  92.         DocumentID: docId,
  93.     }
  95.     deleteResponse, err := delete.Do(context.Background(), client)
  96.     if err != nil {
  97.         fmt.Println("failed to delete document ", err)
  98.         os.Exit(1)
  99.     }
  100.     fmt.Println("deleting document")
  101.     fmt.Println(deleteResponse)
  103.     // Delete previously created index.
  104.     deleteIndex := opensearchapi.IndicesDeleteRequest{
  105.         Index: []string{IndexName},
  106.     }
  108.     deleteIndexResponse, err := deleteIndex.Do(context.Background(), client)
  109.     if err != nil {
  110.         fmt.Println("failed to delete index ", err)
  111.         os.Exit(1)
  112.     }
  113.     fmt.Println("deleting index", deleteIndexResponse)
  114. }