how to use go client - OpenSearch - Centre de documentation Alibaba Cloud

Cette rubrique fournit le code source du client Go pour Alibaba Cloud OpenSearch Industry Algorithm Edition. Ce client gère l'authentification, la signature des requêtes et la communication HTTP avec l'API OpenSearch. Pour les opérations de niveau supérieur, telles que les requêtes et l'indexation, utilisez ce client comme base pour élaborer votre propre logique de requête.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Go installé
Un compte Alibaba Cloud avec OpenSearch Industry Algorithm Edition activé
Un AccessKey ID et un AccessKey Secret

Installer les dépendances

Exécutez les commandes suivantes pour ajouter les packages requis à votre module Go :

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

Code source du client

Le code suivant définit les structures Config et Client, initialise les identifiants et envoie des requêtes HTTP signées à l'API OpenSearch.

Stockez votre AccessKey ID et votre AccessKey Secret dans des variables d'environnement plutôt que de les coder en dur dans le code source.

// This file is auto-generated, don't edit it. Thanks.
/**
 *
 */
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
}

Concepts clés

Champs de configuration

Champ	Type	Description	Valeur par défaut
`Endpoint`	`*string`	Le endpoint du service OpenSearch	`opensearch-cn-hangzhou.aliyuncs.com`
`Protocol`	`*string`	Le protocole de requête	`HTTP`
`Type`	`*string`	Le type d'identifiant	`access_key`
`AccessKeyId`	`*string`	Votre AccessKey ID	—
`AccessKeySecret`	`*string`	Votre AccessKey Secret	—
`SecurityToken`	`*string`	Le jeton de sécurité pour les identifiants temporaires Security Token Service (STS)	—
`UserAgent`	`*string`	Une chaîne user agent personnalisée	—

Comportement des requêtes

La méthode Request définit les en-têtes suivants pour chaque appel : user-agent, Date, host, X-Opensearch-Nonce et Authorization. En présence d'un corps de requête, elle définit également Content-MD5 et Content-Type: application/json. Le client signe chaque requête à l'aide de vos identifiants AccessKey.

Nouvelle tentative et gestion des erreurs

Par défaut, le client effectue jusqu'à 3 tentatives au total (1 tentative initiale plus jusqu'à 2 nouvelles tentatives) sans backoff. Les réponses HTTP 4xx et 5xx sont traitées comme des erreurs. Transmettez une valeur RuntimeOptions à Request pour configurer le délai de lecture, le délai de connexion, le proxy HTTP, le proxy HTTPS, le nombre maximal de connexions inactives, le comportement de nouvelle tentative et la vérification SSL.

Étapes suivantes

Référence de l'API OpenSearch Industry Algorithm Edition