OpenSearch:Kode demo untuk client Go

Prasyarat

Sebelum memulai, pastikan Anda telah:

• Go telah terinstal

• Memiliki Akun Alibaba Cloud dengan OpenSearch Industry Algorithm Edition yang diaktifkan

• Memiliki ID AccessKey dan AccessKey Secret

Instal dependensi

Jalankan perintah berikut untuk menambahkan paket yang diperlukan ke modul Go Anda:

go get github.com/alibabacloud-go/opensearch-util/service
go get github.com/alibabacloud-go/tea-utils/service
go get github.com/alibabacloud-go/tea/tea
go get github.com/aliyun/credentials-go/credentials

Kode sumber client

Kode berikut mendefinisikan struct Config dan Client, menginisialisasi kredensial, dan mengirim permintaan HTTP yang ditandatangani ke API OpenSearch.

Simpan ID AccessKey dan AccessKey Secret Anda dalam variabel lingkungan, bukan dengan hardcoding di kode sumber.

// File ini dibuat secara otomatis, jangan diedit. Terima kasih.
/**
 *
 */
package client

import (
    opensearchutil "github.com/alibabacloud-go/opensearch-util/service"
    util "github.com/alibabacloud-go/tea-utils/service"
    "github.com/alibabacloud-go/tea/tea"
    credential "github.com/aliyun/credentials-go/credentials"
)

type Config struct {
    Endpoint        *string `json:"endpoint,omitempty" xml:"endpoint,omitempty"`
    Protocol        *string `json:"protocol,omitempty" xml:"protocol,omitempty"`
    Type            *string `json:"type,omitempty" xml:"type,omitempty"`
    SecurityToken   *string `json:"securityToken,omitempty" xml:"securityToken,omitempty"`
    AccessKeyId     *string `json:"accessKeyId,omitempty" xml:"accessKeyId,omitempty"`
    AccessKeySecret *string `json:"accessKeySecret,omitempty" xml:"accessKeySecret,omitempty"`
    UserAgent       *string `json:"userAgent,omitempty" xml:"userAgent,omitempty"`
}

func (s Config) String() string {
    return tea.Prettify(s)
}

func (s Config) GoString() string {
    return s.String()
}

func (s *Config) SetEndpoint(v string) *Config {
    s.Endpoint = &v
    return s
}

func (s *Config) SetProtocol(v string) *Config {
    s.Protocol = &v
    return s
}

func (s *Config) SetType(v string) *Config {
    s.Type = &v
    return s
}

func (s *Config) SetSecurityToken(v string) *Config {
    s.SecurityToken = &v
    return s
}

func (s *Config) SetAccessKeyId(v string) *Config {
    s.AccessKeyId = &v
    return s
}

func (s *Config) SetAccessKeySecret(v string) *Config {
    s.AccessKeySecret = &v
    return s
}

func (s *Config) SetUserAgent(v string) *Config {
    s.UserAgent = &v
    return s
}

type Client struct {
    Endpoint   *string
    Protocol   *string
    UserAgent  *string
    Credential credential.Credential
}

func NewClient(config *Config) (*Client, error) {
    client := new(Client)
    err := client.Init(config)
    return client, err
}

func (client *Client) Init(config *Config) (_err error) {
    if tea.BoolValue(util.IsUnset(tea.ToMap(config))) {
        _err = tea.NewSDKError(map[string]interface{}{
            "name":    "ParameterMissing",
            "message": "'config' can not be unset",
        })
        return _err
    }

    if tea.BoolValue(util.Empty(config.Type)) {
        config.Type = tea.String("access_key")
    }

    credentialConfig := &credential.Config{
        AccessKeyId:     config.AccessKeyId,
        Type:            config.Type,
        AccessKeySecret: config.AccessKeySecret,
        SecurityToken:   config.SecurityToken,
    }
    client.Credential, _err = credential.NewCredential(credentialConfig)
    if _err != nil {
        return _err
    }

    client.Endpoint = config.Endpoint
    client.Protocol = config.Protocol
    client.UserAgent = config.UserAgent
    return nil
}

func (client *Client) Request(method *string, pathname *string, query map[string]interface{}, headers map[string]*string, body interface{}, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {
    _err = tea.Validate(runtime)
    if _err != nil {
        return _result, _err
    }
    _runtime := map[string]interface{}{
        "timeouted":      "retry",
        "readTimeout":    tea.IntValue(runtime.ReadTimeout),
        "connectTimeout": tea.IntValue(runtime.ConnectTimeout),
        "httpProxy":      tea.StringValue(runtime.HttpProxy),
        "httpsProxy":     tea.StringValue(runtime.HttpsProxy),
        "noProxy":        tea.StringValue(runtime.NoProxy),
        "maxIdleConns":   tea.IntValue(runtime.MaxIdleConns),
        "retry": map[string]interface{}{
            "retryable":   tea.BoolValue(runtime.Autoretry),
            "maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),
        },
        "backoff": map[string]interface{}{
            "policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),
            "period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),
        },
        "ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),
    }

    _resp := make(map[string]interface{})
    for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {
        if _retryTimes > 0 {
            _backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))
            if tea.IntValue(_backoffTime) > 0 {
                tea.Sleep(_backoffTime)
            }
        }

        _resp, _err = func() (map[string]interface{}, error) {
            request_ := tea.NewRequest()
            accesskeyId, _err := client.GetAccessKeyId()
            if _err != nil {
                return _result, _err
            }

            accessKeySecret, _err := client.GetAccessKeySecret()
            if _err != nil {
                return _result, _err
            }

            request_.Protocol = util.DefaultString(client.Protocol, tea.String("HTTP"))
            request_.Method = method
            request_.Pathname = pathname
            request_.Headers = tea.Merge(map[string]*string{
                "user-agent":         client.GetUserAgent(),
                "Date":               opensearchutil.GetDate(),
                "host":               util.DefaultString(client.Endpoint, tea.String("opensearch-cn-hangzhou.aliyuncs.com")),
                "X-Opensearch-Nonce": util.GetNonce(),
            }, headers)
            if !tea.BoolValue(util.IsUnset(query)) {
                request_.Query = util.StringifyMapValue(query)
            }

            if !tea.BoolValue(util.IsUnset(body)) {
                reqBody := util.ToJSONString(body)
                request_.Headers["Content-MD5"] = opensearchutil.GetContentMD5(reqBody)
                request_.Headers["Content-Type"] = tea.String("application/json")
                request_.Body = tea.ToReader(reqBody)
            }

            request_.Headers["Authorization"] = opensearchutil.GetSignature(request_, accesskeyId, accessKeySecret)
            response_, _err := tea.DoRequest(request_, _runtime)
            if _err != nil {
                return _result, _err
            }
            objStr, _err := util.ReadAsString(response_.Body)
            if _err != nil {
                return _result, _err
            }

            if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {
                _err = tea.NewSDKError(map[string]interface{}{
                    "message": tea.StringValue(response_.StatusMessage),
                    "data":    tea.StringValue(objStr),
                    "code":    tea.IntValue(response_.StatusCode),
                })
                return _result, _err
            }

            obj := util.ParseJSON(objStr)
            res := util.AssertAsMap(obj)
            _result = make(map[string]interface{})
            _err = tea.Convert(map[string]interface{}{
                "body":    res,
                "headers": response_.Headers,
            }, &_result)
            return _result, _err
        }()
        if !tea.BoolValue(tea.Retryable(_err)) {
            break
        }
    }

    return _resp, _err
}

func (client *Client) SetUserAgent(userAgent *string) {
    client.UserAgent = userAgent
}

func (client *Client) AppendUserAgent(userAgent *string) {
    client.UserAgent = tea.String(tea.StringValue(client.UserAgent) + " " + tea.StringValue(userAgent))
}

func (client *Client) GetUserAgent() (_result *string) {
    userAgent := util.GetUserAgent(client.UserAgent)
    _result = userAgent
    return _result
}

func (client *Client) GetAccessKeyId() (_result *string, _err error) {
   if tea.BoolValue(util.IsUnset(client.Credential)) {
       return _result, _err
   }

   accessKeyId, _err := client.Credential.GetAccessKeyId()
   if _err != nil {
       return _result, _err
   }

   _result = accessKeyId
   return _result, _err
}

func (client *Client) GetAccessKeySecret() (_result *string, _err error) {
   if tea.BoolValue(util.IsUnset(client.Credential)) {
       return _result, _err
   }

   secret, _err := client.Credential.GetAccessKeySecret()
   if _err != nil {
       return _result, _err
   }

   _result = secret
   return _result, _err
}

Konsep utama

Langkah selanjutnya

• Referensi API OpenSearch Industry Algorithm Edition