Fetch the repository succeeded.
// Copyright (c) 2017-2018 THL A29 Limited, a Tencent company. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package v20180317
import (
"context"
"errors"
"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
tchttp "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http"
"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
)
const APIVersion = "2018-03-17"
type Client struct {
common.Client
}
// Deprecated
func NewClientWithSecretId(secretId, secretKey, region string) (client *Client, err error) {
cpf := profile.NewClientProfile()
client = &Client{}
client.Init(region).WithSecretId(secretId, secretKey).WithProfile(cpf)
return
}
func NewClient(credential common.CredentialIface, region string, clientProfile *profile.ClientProfile) (client *Client, err error) {
client = &Client{}
client.Init(region).
WithCredential(credential).
WithProfile(clientProfile)
return
}
func NewAssociateTargetGroupsRequest() (request *AssociateTargetGroupsRequest) {
request = &AssociateTargetGroupsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "AssociateTargetGroups")
return
}
func NewAssociateTargetGroupsResponse() (response *AssociateTargetGroupsResponse) {
response = &AssociateTargetGroupsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// AssociateTargetGroups
// 本接口(AssociateTargetGroups)用来将目标组绑定到负载均衡的监听器（四层协议）或转发规则（七层协议）上。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) AssociateTargetGroups(request *AssociateTargetGroupsRequest) (response *AssociateTargetGroupsResponse, err error) {
return c.AssociateTargetGroupsWithContext(context.Background(), request)
}
// AssociateTargetGroups
// 本接口(AssociateTargetGroups)用来将目标组绑定到负载均衡的监听器（四层协议）或转发规则（七层协议）上。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) AssociateTargetGroupsWithContext(ctx context.Context, request *AssociateTargetGroupsRequest) (response *AssociateTargetGroupsResponse, err error) {
if request == nil {
request = NewAssociateTargetGroupsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("AssociateTargetGroups require credential")
}
request.SetContext(ctx)
response = NewAssociateTargetGroupsResponse()
err = c.Send(request, response)
return
}
func NewAutoRewriteRequest() (request *AutoRewriteRequest) {
request = &AutoRewriteRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "AutoRewrite")
return
}
func NewAutoRewriteResponse() (response *AutoRewriteResponse) {
response = &AutoRewriteResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// AutoRewrite
// 用户需要先创建出一个HTTPS:443监听器，并在其下创建转发规则。通过调用本接口，系统会自动创建出一个HTTP:80监听器（如果之前不存在），并在其下创建转发规则，与HTTPS:443监听器下的Domains（在入参中指定）对应。创建成功后可以通过HTTP:80地址自动跳转为HTTPS:443地址进行访问。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REWRITEALREADYEXIST = "InvalidParameter.RewriteAlreadyExist"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) AutoRewrite(request *AutoRewriteRequest) (response *AutoRewriteResponse, err error) {
return c.AutoRewriteWithContext(context.Background(), request)
}
// AutoRewrite
// 用户需要先创建出一个HTTPS:443监听器，并在其下创建转发规则。通过调用本接口，系统会自动创建出一个HTTP:80监听器（如果之前不存在），并在其下创建转发规则，与HTTPS:443监听器下的Domains（在入参中指定）对应。创建成功后可以通过HTTP:80地址自动跳转为HTTPS:443地址进行访问。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REWRITEALREADYEXIST = "InvalidParameter.RewriteAlreadyExist"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) AutoRewriteWithContext(ctx context.Context, request *AutoRewriteRequest) (response *AutoRewriteResponse, err error) {
if request == nil {
request = NewAutoRewriteRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("AutoRewrite require credential")
}
request.SetContext(ctx)
response = NewAutoRewriteResponse()
err = c.Send(request, response)
return
}
func NewBatchDeregisterTargetsRequest() (request *BatchDeregisterTargetsRequest) {
request = &BatchDeregisterTargetsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "BatchDeregisterTargets")
return
}
func NewBatchDeregisterTargetsResponse() (response *BatchDeregisterTargetsResponse) {
response = &BatchDeregisterTargetsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// BatchDeregisterTargets
// 批量解绑四七层后端服务。批量解绑的资源数量上限为500。只支持VPC网络负载均衡。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchDeregisterTargets(request *BatchDeregisterTargetsRequest) (response *BatchDeregisterTargetsResponse, err error) {
return c.BatchDeregisterTargetsWithContext(context.Background(), request)
}
// BatchDeregisterTargets
// 批量解绑四七层后端服务。批量解绑的资源数量上限为500。只支持VPC网络负载均衡。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchDeregisterTargetsWithContext(ctx context.Context, request *BatchDeregisterTargetsRequest) (response *BatchDeregisterTargetsResponse, err error) {
if request == nil {
request = NewBatchDeregisterTargetsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("BatchDeregisterTargets require credential")
}
request.SetContext(ctx)
response = NewBatchDeregisterTargetsResponse()
err = c.Send(request, response)
return
}
func NewBatchModifyTargetTagRequest() (request *BatchModifyTargetTagRequest) {
request = &BatchModifyTargetTagRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "BatchModifyTargetTag")
return
}
func NewBatchModifyTargetTagResponse() (response *BatchModifyTargetTagResponse) {
response = &BatchModifyTargetTagResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// BatchModifyTargetTag
// BatchModifyTargetTag 接口用于批量修改负载均衡监听器绑定的后端机器的标签。批量修改的资源数量上限为500。本接口为同步接口。<br/>负载均衡的4层和7层监听器支持此接口，传统型负载均衡不支持。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchModifyTargetTag(request *BatchModifyTargetTagRequest) (response *BatchModifyTargetTagResponse, err error) {
return c.BatchModifyTargetTagWithContext(context.Background(), request)
}
// BatchModifyTargetTag
// BatchModifyTargetTag 接口用于批量修改负载均衡监听器绑定的后端机器的标签。批量修改的资源数量上限为500。本接口为同步接口。<br/>负载均衡的4层和7层监听器支持此接口，传统型负载均衡不支持。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchModifyTargetTagWithContext(ctx context.Context, request *BatchModifyTargetTagRequest) (response *BatchModifyTargetTagResponse, err error) {
if request == nil {
request = NewBatchModifyTargetTagRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("BatchModifyTargetTag require credential")
}
request.SetContext(ctx)
response = NewBatchModifyTargetTagResponse()
err = c.Send(request, response)
return
}
func NewBatchModifyTargetWeightRequest() (request *BatchModifyTargetWeightRequest) {
request = &BatchModifyTargetWeightRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "BatchModifyTargetWeight")
return
}
func NewBatchModifyTargetWeightResponse() (response *BatchModifyTargetWeightResponse) {
response = &BatchModifyTargetWeightResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// BatchModifyTargetWeight
// BatchModifyTargetWeight 接口用于批量修改负载均衡监听器绑定的后端机器的转发权重。批量修改的资源数量上限为500。本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。<br/>负载均衡的4层和7层监听器支持此接口，传统型负载均衡不支持。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchModifyTargetWeight(request *BatchModifyTargetWeightRequest) (response *BatchModifyTargetWeightResponse, err error) {
return c.BatchModifyTargetWeightWithContext(context.Background(), request)
}
// BatchModifyTargetWeight
// BatchModifyTargetWeight 接口用于批量修改负载均衡监听器绑定的后端机器的转发权重。批量修改的资源数量上限为500。本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。<br/>负载均衡的4层和7层监听器支持此接口，传统型负载均衡不支持。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchModifyTargetWeightWithContext(ctx context.Context, request *BatchModifyTargetWeightRequest) (response *BatchModifyTargetWeightResponse, err error) {
if request == nil {
request = NewBatchModifyTargetWeightRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("BatchModifyTargetWeight require credential")
}
request.SetContext(ctx)
response = NewBatchModifyTargetWeightResponse()
err = c.Send(request, response)
return
}
func NewBatchRegisterTargetsRequest() (request *BatchRegisterTargetsRequest) {
request = &BatchRegisterTargetsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "BatchRegisterTargets")
return
}
func NewBatchRegisterTargetsResponse() (response *BatchRegisterTargetsResponse) {
response = &BatchRegisterTargetsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// BatchRegisterTargets
// 批量绑定虚拟主机或弹性网卡，支持跨域绑定，支持四层、七层（TCP、UDP、HTTP、HTTPS）协议绑定。批量绑定的资源数量上限为500。只支持VPC网络负载均衡。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchRegisterTargets(request *BatchRegisterTargetsRequest) (response *BatchRegisterTargetsResponse, err error) {
return c.BatchRegisterTargetsWithContext(context.Background(), request)
}
// BatchRegisterTargets
// 批量绑定虚拟主机或弹性网卡，支持跨域绑定，支持四层、七层（TCP、UDP、HTTP、HTTPS）协议绑定。批量绑定的资源数量上限为500。只支持VPC网络负载均衡。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) BatchRegisterTargetsWithContext(ctx context.Context, request *BatchRegisterTargetsRequest) (response *BatchRegisterTargetsResponse, err error) {
if request == nil {
request = NewBatchRegisterTargetsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("BatchRegisterTargets require credential")
}
request.SetContext(ctx)
response = NewBatchRegisterTargetsResponse()
err = c.Send(request, response)
return
}
func NewCloneLoadBalancerRequest() (request *CloneLoadBalancerRequest) {
request = &CloneLoadBalancerRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CloneLoadBalancer")
return
}
func NewCloneLoadBalancerResponse() (response *CloneLoadBalancerResponse) {
response = &CloneLoadBalancerResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CloneLoadBalancer
// 克隆负载均衡实例，根据指定的负载均衡实例，复制出相同规则和绑定关系的负载均衡实例。克隆接口为异步操作，克隆的数据以调用CloneLoadBalancer时为准，如果调用CloneLoadBalancer后克隆CLB发生变化，变化规则不会克隆。
//
//
//
// 注：查询实例创建状态可以根据返回值中的requestId访问[DescribeTaskStatus](https://cloud.tencent.com/document/product/214/30683)接口
//
//
//
// 限制说明
//
// 实例属性维度限制：
//
// - 支持克隆网络计费模式为按量计费与包年包月的实例，包年包月实例克隆后的新实例网络计费模式会转换为按小时带宽计费，其带宽、规格与原实例设置保持一致。
//
// - 不支持克隆未关联实例计费项的 CLB。
//
// - 不支持克隆传统型负载均衡实例和高防 CLB。
//
// - 不支持克隆基础网络类型的实例。
//
// - 不支持克隆 Anycast 类型的实例。
//
// - 不支持克隆 IPv6 NAT64 版本的实例。
//
// - 不支持克隆被封禁或冻结的实例。
//
// - 执行克隆操作前，请确保实例上没有使用已过期证书，否则会导致克隆失败。
//
// 配额维度限制：
//
// - 当实例的监听器个数超过 50 个时，不支持克隆。
//
// - 当共享型实例的公网带宽上限超过 2G 时，不支持克隆。
//
//
//
// 通过接口调用：
//
// BGP带宽包必须传带宽包id
//
// 独占集群克隆必须传对应的参数，否则按共享型创建
//
// 功能内测中，请提交 [内测申请](https://cloud.tencent.com/apply/p/1akuvsmyn0g)。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// DRYRUNOPERATION = "DryRunOperation"
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// OPERATIONDENIED = "OperationDenied"
// REQUESTLIMITEXCEEDED = "RequestLimitExceeded"
// RESOURCEINUSE = "ResourceInUse"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// RESOURCESSOLDOUT = "ResourcesSoldOut"
func (c *Client) CloneLoadBalancer(request *CloneLoadBalancerRequest) (response *CloneLoadBalancerResponse, err error) {
return c.CloneLoadBalancerWithContext(context.Background(), request)
}
// CloneLoadBalancer
// 克隆负载均衡实例，根据指定的负载均衡实例，复制出相同规则和绑定关系的负载均衡实例。克隆接口为异步操作，克隆的数据以调用CloneLoadBalancer时为准，如果调用CloneLoadBalancer后克隆CLB发生变化，变化规则不会克隆。
//
//
//
// 注：查询实例创建状态可以根据返回值中的requestId访问[DescribeTaskStatus](https://cloud.tencent.com/document/product/214/30683)接口
//
//
//
// 限制说明
//
// 实例属性维度限制：
//
// - 支持克隆网络计费模式为按量计费与包年包月的实例，包年包月实例克隆后的新实例网络计费模式会转换为按小时带宽计费，其带宽、规格与原实例设置保持一致。
//
// - 不支持克隆未关联实例计费项的 CLB。
//
// - 不支持克隆传统型负载均衡实例和高防 CLB。
//
// - 不支持克隆基础网络类型的实例。
//
// - 不支持克隆 Anycast 类型的实例。
//
// - 不支持克隆 IPv6 NAT64 版本的实例。
//
// - 不支持克隆被封禁或冻结的实例。
//
// - 执行克隆操作前，请确保实例上没有使用已过期证书，否则会导致克隆失败。
//
// 配额维度限制：
//
// - 当实例的监听器个数超过 50 个时，不支持克隆。
//
// - 当共享型实例的公网带宽上限超过 2G 时，不支持克隆。
//
//
//
// 通过接口调用：
//
// BGP带宽包必须传带宽包id
//
// 独占集群克隆必须传对应的参数，否则按共享型创建
//
// 功能内测中，请提交 [内测申请](https://cloud.tencent.com/apply/p/1akuvsmyn0g)。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// DRYRUNOPERATION = "DryRunOperation"
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// OPERATIONDENIED = "OperationDenied"
// REQUESTLIMITEXCEEDED = "RequestLimitExceeded"
// RESOURCEINUSE = "ResourceInUse"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// RESOURCESSOLDOUT = "ResourcesSoldOut"
func (c *Client) CloneLoadBalancerWithContext(ctx context.Context, request *CloneLoadBalancerRequest) (response *CloneLoadBalancerResponse, err error) {
if request == nil {
request = NewCloneLoadBalancerRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CloneLoadBalancer require credential")
}
request.SetContext(ctx)
response = NewCloneLoadBalancerResponse()
err = c.Send(request, response)
return
}
func NewCreateClsLogSetRequest() (request *CreateClsLogSetRequest) {
request = &CreateClsLogSetRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CreateClsLogSet")
return
}
func NewCreateClsLogSetResponse() (response *CreateClsLogSetResponse) {
response = &CreateClsLogSetResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CreateClsLogSet
// 创建CLB专有日志集，此日志集用于存储CLB的日志。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateClsLogSet(request *CreateClsLogSetRequest) (response *CreateClsLogSetResponse, err error) {
return c.CreateClsLogSetWithContext(context.Background(), request)
}
// CreateClsLogSet
// 创建CLB专有日志集，此日志集用于存储CLB的日志。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateClsLogSetWithContext(ctx context.Context, request *CreateClsLogSetRequest) (response *CreateClsLogSetResponse, err error) {
if request == nil {
request = NewCreateClsLogSetRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CreateClsLogSet require credential")
}
request.SetContext(ctx)
response = NewCreateClsLogSetResponse()
err = c.Send(request, response)
return
}
func NewCreateListenerRequest() (request *CreateListenerRequest) {
request = &CreateListenerRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CreateListener")
return
}
func NewCreateListenerResponse() (response *CreateListenerResponse) {
response = &CreateListenerResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CreateListener
// 在一个负载均衡实例下创建监听器。
//
// 本接口为异步接口，接口返回成功后，需以返回的 RequestId 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateListener(request *CreateListenerRequest) (response *CreateListenerResponse, err error) {
return c.CreateListenerWithContext(context.Background(), request)
}
// CreateListener
// 在一个负载均衡实例下创建监听器。
//
// 本接口为异步接口，接口返回成功后，需以返回的 RequestId 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateListenerWithContext(ctx context.Context, request *CreateListenerRequest) (response *CreateListenerResponse, err error) {
if request == nil {
request = NewCreateListenerRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CreateListener require credential")
}
request.SetContext(ctx)
response = NewCreateListenerResponse()
err = c.Send(request, response)
return
}
func NewCreateLoadBalancerRequest() (request *CreateLoadBalancerRequest) {
request = &CreateLoadBalancerRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CreateLoadBalancer")
return
}
func NewCreateLoadBalancerResponse() (response *CreateLoadBalancerResponse) {
response = &CreateLoadBalancerResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CreateLoadBalancer
// 本接口(CreateLoadBalancer)用来创建负载均衡实例（本接口只支持购买按量计费的负载均衡，包年包月的负载均衡请通过控制台购买）。为了使用负载均衡服务，您必须购买一个或多个负载均衡实例。成功调用该接口后，会返回负载均衡实例的唯一 ID。负载均衡实例的类型分为：公网、内网。详情可参考产品说明中的产品类型。
//
// 注意：(1)指定可用区申请负载均衡、跨zone容灾(仅香港支持)【如果您需要体验该功能，请通过 [工单申请](https://console.cloud.tencent.com/workorder/category)】；(2)目前只有北京、上海、广州支持IPv6；(3)一个账号在每个地域的默认购买配额为：公网100个，内网100个。
//
// 本接口为异步接口，接口成功返回后，可使用 DescribeLoadBalancers 接口查询负载均衡实例的状态（如创建中、正常），以确定是否创建成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_CLIENTTOKENLIMITEXCEEDED = "InvalidParameter.ClientTokenLimitExceeded"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
// UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) CreateLoadBalancer(request *CreateLoadBalancerRequest) (response *CreateLoadBalancerResponse, err error) {
return c.CreateLoadBalancerWithContext(context.Background(), request)
}
// CreateLoadBalancer
// 本接口(CreateLoadBalancer)用来创建负载均衡实例（本接口只支持购买按量计费的负载均衡，包年包月的负载均衡请通过控制台购买）。为了使用负载均衡服务，您必须购买一个或多个负载均衡实例。成功调用该接口后，会返回负载均衡实例的唯一 ID。负载均衡实例的类型分为：公网、内网。详情可参考产品说明中的产品类型。
//
// 注意：(1)指定可用区申请负载均衡、跨zone容灾(仅香港支持)【如果您需要体验该功能，请通过 [工单申请](https://console.cloud.tencent.com/workorder/category)】；(2)目前只有北京、上海、广州支持IPv6；(3)一个账号在每个地域的默认购买配额为：公网100个，内网100个。
//
// 本接口为异步接口，接口成功返回后，可使用 DescribeLoadBalancers 接口查询负载均衡实例的状态（如创建中、正常），以确定是否创建成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_CLIENTTOKENLIMITEXCEEDED = "InvalidParameter.ClientTokenLimitExceeded"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
// UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) CreateLoadBalancerWithContext(ctx context.Context, request *CreateLoadBalancerRequest) (response *CreateLoadBalancerResponse, err error) {
if request == nil {
request = NewCreateLoadBalancerRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CreateLoadBalancer require credential")
}
request.SetContext(ctx)
response = NewCreateLoadBalancerResponse()
err = c.Send(request, response)
return
}
func NewCreateLoadBalancerSnatIpsRequest() (request *CreateLoadBalancerSnatIpsRequest) {
request = &CreateLoadBalancerSnatIpsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CreateLoadBalancerSnatIps")
return
}
func NewCreateLoadBalancerSnatIpsResponse() (response *CreateLoadBalancerSnatIpsResponse) {
response = &CreateLoadBalancerSnatIpsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CreateLoadBalancerSnatIps
// 针对SnatPro负载均衡，这个接口用于添加SnatIp，如果负载均衡没有开启SnatPro，添加SnatIp后会自动开启。
//
// 本接口为异步接口，接口返回成功后，需以得到的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
func (c *Client) CreateLoadBalancerSnatIps(request *CreateLoadBalancerSnatIpsRequest) (response *CreateLoadBalancerSnatIpsResponse, err error) {
return c.CreateLoadBalancerSnatIpsWithContext(context.Background(), request)
}
// CreateLoadBalancerSnatIps
// 针对SnatPro负载均衡，这个接口用于添加SnatIp，如果负载均衡没有开启SnatPro，添加SnatIp后会自动开启。
//
// 本接口为异步接口，接口返回成功后，需以得到的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
func (c *Client) CreateLoadBalancerSnatIpsWithContext(ctx context.Context, request *CreateLoadBalancerSnatIpsRequest) (response *CreateLoadBalancerSnatIpsResponse, err error) {
if request == nil {
request = NewCreateLoadBalancerSnatIpsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CreateLoadBalancerSnatIps require credential")
}
request.SetContext(ctx)
response = NewCreateLoadBalancerSnatIpsResponse()
err = c.Send(request, response)
return
}
func NewCreateRuleRequest() (request *CreateRuleRequest) {
request = &CreateRuleRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CreateRule")
return
}
func NewCreateRuleResponse() (response *CreateRuleResponse) {
response = &CreateRuleResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CreateRule
// CreateRule 接口用于在一个已存在的负载均衡七层监听器下创建转发规则，七层监听器中，后端服务必须绑定到规则上而非监听器上。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateRule(request *CreateRuleRequest) (response *CreateRuleResponse, err error) {
return c.CreateRuleWithContext(context.Background(), request)
}
// CreateRule
// CreateRule 接口用于在一个已存在的负载均衡七层监听器下创建转发规则，七层监听器中，后端服务必须绑定到规则上而非监听器上。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateRuleWithContext(ctx context.Context, request *CreateRuleRequest) (response *CreateRuleResponse, err error) {
if request == nil {
request = NewCreateRuleRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CreateRule require credential")
}
request.SetContext(ctx)
response = NewCreateRuleResponse()
err = c.Send(request, response)
return
}
func NewCreateTargetGroupRequest() (request *CreateTargetGroupRequest) {
request = &CreateTargetGroupRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CreateTargetGroup")
return
}
func NewCreateTargetGroupResponse() (response *CreateTargetGroupResponse) {
response = &CreateTargetGroupResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CreateTargetGroup
// 创建目标组。该功能正在内测中，如需使用，请通过[工单申请](https://console.cloud.tencent.com/workorder/category?level1_id=6&level2_id=163&source=0&data_title=%E8%B4%9F%E8%BD%BD%E5%9D%87%E8%A1%A1%20LB&step=1)。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateTargetGroup(request *CreateTargetGroupRequest) (response *CreateTargetGroupResponse, err error) {
return c.CreateTargetGroupWithContext(context.Background(), request)
}
// CreateTargetGroup
// 创建目标组。该功能正在内测中，如需使用，请通过[工单申请](https://console.cloud.tencent.com/workorder/category?level1_id=6&level2_id=163&source=0&data_title=%E8%B4%9F%E8%BD%BD%E5%9D%87%E8%A1%A1%20LB&step=1)。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateTargetGroupWithContext(ctx context.Context, request *CreateTargetGroupRequest) (response *CreateTargetGroupResponse, err error) {
if request == nil {
request = NewCreateTargetGroupRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CreateTargetGroup require credential")
}
request.SetContext(ctx)
response = NewCreateTargetGroupResponse()
err = c.Send(request, response)
return
}
func NewCreateTopicRequest() (request *CreateTopicRequest) {
request = &CreateTopicRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "CreateTopic")
return
}
func NewCreateTopicResponse() (response *CreateTopicResponse) {
response = &CreateTopicResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// CreateTopic
// 创建主题，默认开启全文索引和键值索引。如果不存在CLB专有日志集，则创建失败。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateTopic(request *CreateTopicRequest) (response *CreateTopicResponse, err error) {
return c.CreateTopicWithContext(context.Background(), request)
}
// CreateTopic
// 创建主题，默认开启全文索引和键值索引。如果不存在CLB专有日志集，则创建失败。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) CreateTopicWithContext(ctx context.Context, request *CreateTopicRequest) (response *CreateTopicResponse, err error) {
if request == nil {
request = NewCreateTopicRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("CreateTopic require credential")
}
request.SetContext(ctx)
response = NewCreateTopicResponse()
err = c.Send(request, response)
return
}
func NewDeleteListenerRequest() (request *DeleteListenerRequest) {
request = &DeleteListenerRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeleteListener")
return
}
func NewDeleteListenerResponse() (response *DeleteListenerResponse) {
response = &DeleteListenerResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeleteListener
// 本接口用来删除负载均衡实例下的监听器（四层和七层）。
//
// 本接口为异步接口，接口返回成功后，需以得到的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteListener(request *DeleteListenerRequest) (response *DeleteListenerResponse, err error) {
return c.DeleteListenerWithContext(context.Background(), request)
}
// DeleteListener
// 本接口用来删除负载均衡实例下的监听器（四层和七层）。
//
// 本接口为异步接口，接口返回成功后，需以得到的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteListenerWithContext(ctx context.Context, request *DeleteListenerRequest) (response *DeleteListenerResponse, err error) {
if request == nil {
request = NewDeleteListenerRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeleteListener require credential")
}
request.SetContext(ctx)
response = NewDeleteListenerResponse()
err = c.Send(request, response)
return
}
func NewDeleteLoadBalancerRequest() (request *DeleteLoadBalancerRequest) {
request = &DeleteLoadBalancerRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeleteLoadBalancer")
return
}
func NewDeleteLoadBalancerResponse() (response *DeleteLoadBalancerResponse) {
response = &DeleteLoadBalancerResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeleteLoadBalancer
// DeleteLoadBalancer 接口用以删除指定的一个或多个负载均衡实例。成功删除后，会把负载均衡实例下的监听器、转发规则一起删除，并把后端服务解绑。
//
// 本接口为异步接口，接口返回成功后，需以返回的 RequestId 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteLoadBalancer(request *DeleteLoadBalancerRequest) (response *DeleteLoadBalancerResponse, err error) {
return c.DeleteLoadBalancerWithContext(context.Background(), request)
}
// DeleteLoadBalancer
// DeleteLoadBalancer 接口用以删除指定的一个或多个负载均衡实例。成功删除后，会把负载均衡实例下的监听器、转发规则一起删除，并把后端服务解绑。
//
// 本接口为异步接口，接口返回成功后，需以返回的 RequestId 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteLoadBalancerWithContext(ctx context.Context, request *DeleteLoadBalancerRequest) (response *DeleteLoadBalancerResponse, err error) {
if request == nil {
request = NewDeleteLoadBalancerRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeleteLoadBalancer require credential")
}
request.SetContext(ctx)
response = NewDeleteLoadBalancerResponse()
err = c.Send(request, response)
return
}
func NewDeleteLoadBalancerListenersRequest() (request *DeleteLoadBalancerListenersRequest) {
request = &DeleteLoadBalancerListenersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeleteLoadBalancerListeners")
return
}
func NewDeleteLoadBalancerListenersResponse() (response *DeleteLoadBalancerListenersResponse) {
response = &DeleteLoadBalancerListenersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeleteLoadBalancerListeners
// 该接口支持删除负载均衡的多个监听器。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteLoadBalancerListeners(request *DeleteLoadBalancerListenersRequest) (response *DeleteLoadBalancerListenersResponse, err error) {
return c.DeleteLoadBalancerListenersWithContext(context.Background(), request)
}
// DeleteLoadBalancerListeners
// 该接口支持删除负载均衡的多个监听器。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteLoadBalancerListenersWithContext(ctx context.Context, request *DeleteLoadBalancerListenersRequest) (response *DeleteLoadBalancerListenersResponse, err error) {
if request == nil {
request = NewDeleteLoadBalancerListenersRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeleteLoadBalancerListeners require credential")
}
request.SetContext(ctx)
response = NewDeleteLoadBalancerListenersResponse()
err = c.Send(request, response)
return
}
func NewDeleteLoadBalancerSnatIpsRequest() (request *DeleteLoadBalancerSnatIpsRequest) {
request = &DeleteLoadBalancerSnatIpsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeleteLoadBalancerSnatIps")
return
}
func NewDeleteLoadBalancerSnatIpsResponse() (response *DeleteLoadBalancerSnatIpsResponse) {
response = &DeleteLoadBalancerSnatIpsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeleteLoadBalancerSnatIps
// 这个接口用于删除SnatPro的负载均衡的SnatIp。
//
// 本接口为异步接口，接口返回成功后，需以得到的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
func (c *Client) DeleteLoadBalancerSnatIps(request *DeleteLoadBalancerSnatIpsRequest) (response *DeleteLoadBalancerSnatIpsResponse, err error) {
return c.DeleteLoadBalancerSnatIpsWithContext(context.Background(), request)
}
// DeleteLoadBalancerSnatIps
// 这个接口用于删除SnatPro的负载均衡的SnatIp。
//
// 本接口为异步接口，接口返回成功后，需以得到的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// LIMITEXCEEDED = "LimitExceeded"
func (c *Client) DeleteLoadBalancerSnatIpsWithContext(ctx context.Context, request *DeleteLoadBalancerSnatIpsRequest) (response *DeleteLoadBalancerSnatIpsResponse, err error) {
if request == nil {
request = NewDeleteLoadBalancerSnatIpsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeleteLoadBalancerSnatIps require credential")
}
request.SetContext(ctx)
response = NewDeleteLoadBalancerSnatIpsResponse()
err = c.Send(request, response)
return
}
func NewDeleteRewriteRequest() (request *DeleteRewriteRequest) {
request = &DeleteRewriteRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeleteRewrite")
return
}
func NewDeleteRewriteResponse() (response *DeleteRewriteResponse) {
response = &DeleteRewriteResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeleteRewrite
// DeleteRewrite 接口支持删除指定转发规则之间的重定向关系。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_SOMEREWRITENOTFOUND = "InvalidParameter.SomeRewriteNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteRewrite(request *DeleteRewriteRequest) (response *DeleteRewriteResponse, err error) {
return c.DeleteRewriteWithContext(context.Background(), request)
}
// DeleteRewrite
// DeleteRewrite 接口支持删除指定转发规则之间的重定向关系。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_SOMEREWRITENOTFOUND = "InvalidParameter.SomeRewriteNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteRewriteWithContext(ctx context.Context, request *DeleteRewriteRequest) (response *DeleteRewriteResponse, err error) {
if request == nil {
request = NewDeleteRewriteRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeleteRewrite require credential")
}
request.SetContext(ctx)
response = NewDeleteRewriteResponse()
err = c.Send(request, response)
return
}
func NewDeleteRuleRequest() (request *DeleteRuleRequest) {
request = &DeleteRuleRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeleteRule")
return
}
func NewDeleteRuleResponse() (response *DeleteRuleResponse) {
response = &DeleteRuleResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeleteRule
// DeleteRule 接口用来删除负载均衡实例七层监听器下的转发规则。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteRule(request *DeleteRuleRequest) (response *DeleteRuleResponse, err error) {
return c.DeleteRuleWithContext(context.Background(), request)
}
// DeleteRule
// DeleteRule 接口用来删除负载均衡实例七层监听器下的转发规则。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteRuleWithContext(ctx context.Context, request *DeleteRuleRequest) (response *DeleteRuleResponse, err error) {
if request == nil {
request = NewDeleteRuleRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeleteRule require credential")
}
request.SetContext(ctx)
response = NewDeleteRuleResponse()
err = c.Send(request, response)
return
}
func NewDeleteTargetGroupsRequest() (request *DeleteTargetGroupsRequest) {
request = &DeleteTargetGroupsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeleteTargetGroups")
return
}
func NewDeleteTargetGroupsResponse() (response *DeleteTargetGroupsResponse) {
response = &DeleteTargetGroupsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeleteTargetGroups
// 删除目标组
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteTargetGroups(request *DeleteTargetGroupsRequest) (response *DeleteTargetGroupsResponse, err error) {
return c.DeleteTargetGroupsWithContext(context.Background(), request)
}
// DeleteTargetGroups
// 删除目标组
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeleteTargetGroupsWithContext(ctx context.Context, request *DeleteTargetGroupsRequest) (response *DeleteTargetGroupsResponse, err error) {
if request == nil {
request = NewDeleteTargetGroupsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeleteTargetGroups require credential")
}
request.SetContext(ctx)
response = NewDeleteTargetGroupsResponse()
err = c.Send(request, response)
return
}
func NewDeregisterFunctionTargetsRequest() (request *DeregisterFunctionTargetsRequest) {
request = &DeregisterFunctionTargetsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeregisterFunctionTargets")
return
}
func NewDeregisterFunctionTargetsResponse() (response *DeregisterFunctionTargetsResponse) {
response = &DeregisterFunctionTargetsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeregisterFunctionTargets
// DeregisterFunctionTargets 接口用来将一个云函数从负载均衡的转发规则上解绑，对于七层监听器，还需通过 LocationId 或 Domain+Url 指定转发规则。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 [DescribeTaskStatus](https://cloud.tencent.com/document/product/214/30683) 接口查询本次任务是否成功。
//
// <br/>限制说明：
//
//
//
// - 仅广州、深圳金融、上海、上海金融、北京、成都、中国香港、新加坡、孟买、东京、硅谷地域支持绑定 SCF。
//
// - 仅标准账户类型支持绑定 SCF，传统账户类型不支持。建议升级为标准账户类型，详情可参见 [账户类型升级说明](https://cloud.tencent.com/document/product/1199/49090)。
//
// - 传统型负载均衡不支持绑定 SCF。
//
// - 基础网络类型不支持绑定 SCF。
//
// - CLB 默认支持绑定同地域下的所有 SCF，可支持跨 VPC 绑定 SCF，不支持跨地域绑定。
//
// - 目前仅 IPv4、IPv6 NAT64 版本的负载均衡支持绑定 SCF，IPv6 版本的暂不支持。
//
// - 仅七层（HTTP、HTTPS）监听器支持绑定 SCF，四层（TCP、UDP、TCP SSL）监听器和七层 QUIC 监听器不支持。
//
// - CLB 绑定 SCF 仅支持绑定“Event 函数”类型的云函数。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCENOTFOUND = "ResourceNotFound"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterFunctionTargets(request *DeregisterFunctionTargetsRequest) (response *DeregisterFunctionTargetsResponse, err error) {
return c.DeregisterFunctionTargetsWithContext(context.Background(), request)
}
// DeregisterFunctionTargets
// DeregisterFunctionTargets 接口用来将一个云函数从负载均衡的转发规则上解绑，对于七层监听器，还需通过 LocationId 或 Domain+Url 指定转发规则。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 [DescribeTaskStatus](https://cloud.tencent.com/document/product/214/30683) 接口查询本次任务是否成功。
//
// <br/>限制说明：
//
//
//
// - 仅广州、深圳金融、上海、上海金融、北京、成都、中国香港、新加坡、孟买、东京、硅谷地域支持绑定 SCF。
//
// - 仅标准账户类型支持绑定 SCF，传统账户类型不支持。建议升级为标准账户类型，详情可参见 [账户类型升级说明](https://cloud.tencent.com/document/product/1199/49090)。
//
// - 传统型负载均衡不支持绑定 SCF。
//
// - 基础网络类型不支持绑定 SCF。
//
// - CLB 默认支持绑定同地域下的所有 SCF，可支持跨 VPC 绑定 SCF，不支持跨地域绑定。
//
// - 目前仅 IPv4、IPv6 NAT64 版本的负载均衡支持绑定 SCF，IPv6 版本的暂不支持。
//
// - 仅七层（HTTP、HTTPS）监听器支持绑定 SCF，四层（TCP、UDP、TCP SSL）监听器和七层 QUIC 监听器不支持。
//
// - CLB 绑定 SCF 仅支持绑定“Event 函数”类型的云函数。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCENOTFOUND = "ResourceNotFound"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterFunctionTargetsWithContext(ctx context.Context, request *DeregisterFunctionTargetsRequest) (response *DeregisterFunctionTargetsResponse, err error) {
if request == nil {
request = NewDeregisterFunctionTargetsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeregisterFunctionTargets require credential")
}
request.SetContext(ctx)
response = NewDeregisterFunctionTargetsResponse()
err = c.Send(request, response)
return
}
func NewDeregisterTargetGroupInstancesRequest() (request *DeregisterTargetGroupInstancesRequest) {
request = &DeregisterTargetGroupInstancesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeregisterTargetGroupInstances")
return
}
func NewDeregisterTargetGroupInstancesResponse() (response *DeregisterTargetGroupInstancesResponse) {
response = &DeregisterTargetGroupInstancesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeregisterTargetGroupInstances
// 从目标组中解绑服务器。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterTargetGroupInstances(request *DeregisterTargetGroupInstancesRequest) (response *DeregisterTargetGroupInstancesResponse, err error) {
return c.DeregisterTargetGroupInstancesWithContext(context.Background(), request)
}
// DeregisterTargetGroupInstances
// 从目标组中解绑服务器。
//
// 本接口为异步接口，本接口返回成功后需以返回的 RequestID 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_RESOURCEINOPERATING = "FailedOperation.ResourceInOperating"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterTargetGroupInstancesWithContext(ctx context.Context, request *DeregisterTargetGroupInstancesRequest) (response *DeregisterTargetGroupInstancesResponse, err error) {
if request == nil {
request = NewDeregisterTargetGroupInstancesRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeregisterTargetGroupInstances require credential")
}
request.SetContext(ctx)
response = NewDeregisterTargetGroupInstancesResponse()
err = c.Send(request, response)
return
}
func NewDeregisterTargetsRequest() (request *DeregisterTargetsRequest) {
request = &DeregisterTargetsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeregisterTargets")
return
}
func NewDeregisterTargetsResponse() (response *DeregisterTargetsResponse) {
response = &DeregisterTargetsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeregisterTargets
// DeregisterTargets 接口用来将一台或多台后端服务从负载均衡的监听器或转发规则上解绑，对于四层监听器，只需指定监听器ID即可，对于七层监听器，还需通过LocationId或Domain+Url指定转发规则。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterTargets(request *DeregisterTargetsRequest) (response *DeregisterTargetsResponse, err error) {
return c.DeregisterTargetsWithContext(context.Background(), request)
}
// DeregisterTargets
// DeregisterTargets 接口用来将一台或多台后端服务从负载均衡的监听器或转发规则上解绑，对于四层监听器，只需指定监听器ID即可，对于七层监听器，还需通过LocationId或Domain+Url指定转发规则。
//
// 本接口为异步接口，本接口返回成功后需以返回的RequestID为入参，调用DescribeTaskStatus接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterTargetsWithContext(ctx context.Context, request *DeregisterTargetsRequest) (response *DeregisterTargetsResponse, err error) {
if request == nil {
request = NewDeregisterTargetsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeregisterTargets require credential")
}
request.SetContext(ctx)
response = NewDeregisterTargetsResponse()
err = c.Send(request, response)
return
}
func NewDeregisterTargetsFromClassicalLBRequest() (request *DeregisterTargetsFromClassicalLBRequest) {
request = &DeregisterTargetsFromClassicalLBRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DeregisterTargetsFromClassicalLB")
return
}
func NewDeregisterTargetsFromClassicalLBResponse() (response *DeregisterTargetsFromClassicalLBResponse) {
response = &DeregisterTargetsFromClassicalLBResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DeregisterTargetsFromClassicalLB
// DeregisterTargetsFromClassicalLB 接口用于解绑负载均衡后端服务。本接口为异步接口，接口返回成功后，需以返回的 RequestId 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterTargetsFromClassicalLB(request *DeregisterTargetsFromClassicalLBRequest) (response *DeregisterTargetsFromClassicalLBResponse, err error) {
return c.DeregisterTargetsFromClassicalLBWithContext(context.Background(), request)
}
// DeregisterTargetsFromClassicalLB
// DeregisterTargetsFromClassicalLB 接口用于解绑负载均衡后端服务。本接口为异步接口，接口返回成功后，需以返回的 RequestId 为入参，调用 DescribeTaskStatus 接口查询本次任务是否成功。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DeregisterTargetsFromClassicalLBWithContext(ctx context.Context, request *DeregisterTargetsFromClassicalLBRequest) (response *DeregisterTargetsFromClassicalLBResponse, err error) {
if request == nil {
request = NewDeregisterTargetsFromClassicalLBRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DeregisterTargetsFromClassicalLB require credential")
}
request.SetContext(ctx)
response = NewDeregisterTargetsFromClassicalLBResponse()
err = c.Send(request, response)
return
}
func NewDescribeBlockIPListRequest() (request *DescribeBlockIPListRequest) {
request = &DescribeBlockIPListRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeBlockIPList")
return
}
func NewDescribeBlockIPListResponse() (response *DescribeBlockIPListResponse) {
response = &DescribeBlockIPListResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeBlockIPList
// 查询一个负载均衡所封禁的IP列表（黑名单）。（接口灰度中，如需使用请提工单）
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeBlockIPList(request *DescribeBlockIPListRequest) (response *DescribeBlockIPListResponse, err error) {
return c.DescribeBlockIPListWithContext(context.Background(), request)
}
// DescribeBlockIPList
// 查询一个负载均衡所封禁的IP列表（黑名单）。（接口灰度中，如需使用请提工单）
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeBlockIPListWithContext(ctx context.Context, request *DescribeBlockIPListRequest) (response *DescribeBlockIPListResponse, err error) {
if request == nil {
request = NewDescribeBlockIPListRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeBlockIPList require credential")
}
request.SetContext(ctx)
response = NewDescribeBlockIPListResponse()
err = c.Send(request, response)
return
}
func NewDescribeBlockIPTaskRequest() (request *DescribeBlockIPTaskRequest) {
request = &DescribeBlockIPTaskRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeBlockIPTask")
return
}
func NewDescribeBlockIPTaskResponse() (response *DescribeBlockIPTaskResponse) {
response = &DescribeBlockIPTaskResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeBlockIPTask
// 根据 ModifyBlockIPList 接口返回的异步任务的ID，查询封禁IP（黑名单）异步任务的执行状态。（接口灰度中，如需使用请提工单）
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeBlockIPTask(request *DescribeBlockIPTaskRequest) (response *DescribeBlockIPTaskResponse, err error) {
return c.DescribeBlockIPTaskWithContext(context.Background(), request)
}
// DescribeBlockIPTask
// 根据 ModifyBlockIPList 接口返回的异步任务的ID，查询封禁IP（黑名单）异步任务的执行状态。（接口灰度中，如需使用请提工单）
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeBlockIPTaskWithContext(ctx context.Context, request *DescribeBlockIPTaskRequest) (response *DescribeBlockIPTaskResponse, err error) {
if request == nil {
request = NewDescribeBlockIPTaskRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeBlockIPTask require credential")
}
request.SetContext(ctx)
response = NewDescribeBlockIPTaskResponse()
err = c.Send(request, response)
return
}
func NewDescribeClassicalLBByInstanceIdRequest() (request *DescribeClassicalLBByInstanceIdRequest) {
request = &DescribeClassicalLBByInstanceIdRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeClassicalLBByInstanceId")
return
}
func NewDescribeClassicalLBByInstanceIdResponse() (response *DescribeClassicalLBByInstanceIdResponse) {
response = &DescribeClassicalLBByInstanceIdResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeClassicalLBByInstanceId
// DescribeClassicalLBByInstanceId用于通过后端实例ID获取传统型负载均衡ID列表。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClassicalLBByInstanceId(request *DescribeClassicalLBByInstanceIdRequest) (response *DescribeClassicalLBByInstanceIdResponse, err error) {
return c.DescribeClassicalLBByInstanceIdWithContext(context.Background(), request)
}
// DescribeClassicalLBByInstanceId
// DescribeClassicalLBByInstanceId用于通过后端实例ID获取传统型负载均衡ID列表。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClassicalLBByInstanceIdWithContext(ctx context.Context, request *DescribeClassicalLBByInstanceIdRequest) (response *DescribeClassicalLBByInstanceIdResponse, err error) {
if request == nil {
request = NewDescribeClassicalLBByInstanceIdRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeClassicalLBByInstanceId require credential")
}
request.SetContext(ctx)
response = NewDescribeClassicalLBByInstanceIdResponse()
err = c.Send(request, response)
return
}
func NewDescribeClassicalLBHealthStatusRequest() (request *DescribeClassicalLBHealthStatusRequest) {
request = &DescribeClassicalLBHealthStatusRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeClassicalLBHealthStatus")
return
}
func NewDescribeClassicalLBHealthStatusResponse() (response *DescribeClassicalLBHealthStatusResponse) {
response = &DescribeClassicalLBHealthStatusResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeClassicalLBHealthStatus
// DescribeClassicalLBHealthStatus用于获取传统型负载均衡后端的健康状态
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClassicalLBHealthStatus(request *DescribeClassicalLBHealthStatusRequest) (response *DescribeClassicalLBHealthStatusResponse, err error) {
return c.DescribeClassicalLBHealthStatusWithContext(context.Background(), request)
}
// DescribeClassicalLBHealthStatus
// DescribeClassicalLBHealthStatus用于获取传统型负载均衡后端的健康状态
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClassicalLBHealthStatusWithContext(ctx context.Context, request *DescribeClassicalLBHealthStatusRequest) (response *DescribeClassicalLBHealthStatusResponse, err error) {
if request == nil {
request = NewDescribeClassicalLBHealthStatusRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeClassicalLBHealthStatus require credential")
}
request.SetContext(ctx)
response = NewDescribeClassicalLBHealthStatusResponse()
err = c.Send(request, response)
return
}
func NewDescribeClassicalLBListenersRequest() (request *DescribeClassicalLBListenersRequest) {
request = &DescribeClassicalLBListenersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeClassicalLBListeners")
return
}
func NewDescribeClassicalLBListenersResponse() (response *DescribeClassicalLBListenersResponse) {
response = &DescribeClassicalLBListenersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeClassicalLBListeners
// DescribeClassicalLBListeners 接口用于获取传统型负载均衡的监听器信息。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
// UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeClassicalLBListeners(request *DescribeClassicalLBListenersRequest) (response *DescribeClassicalLBListenersResponse, err error) {
return c.DescribeClassicalLBListenersWithContext(context.Background(), request)
}
// DescribeClassicalLBListeners
// DescribeClassicalLBListeners 接口用于获取传统型负载均衡的监听器信息。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
// UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeClassicalLBListenersWithContext(ctx context.Context, request *DescribeClassicalLBListenersRequest) (response *DescribeClassicalLBListenersResponse, err error) {
if request == nil {
request = NewDescribeClassicalLBListenersRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeClassicalLBListeners require credential")
}
request.SetContext(ctx)
response = NewDescribeClassicalLBListenersResponse()
err = c.Send(request, response)
return
}
func NewDescribeClassicalLBTargetsRequest() (request *DescribeClassicalLBTargetsRequest) {
request = &DescribeClassicalLBTargetsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeClassicalLBTargets")
return
}
func NewDescribeClassicalLBTargetsResponse() (response *DescribeClassicalLBTargetsResponse) {
response = &DescribeClassicalLBTargetsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeClassicalLBTargets
// DescribeClassicalLBTargets用于获取传统型负载均衡绑定的后端服务。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClassicalLBTargets(request *DescribeClassicalLBTargetsRequest) (response *DescribeClassicalLBTargetsResponse, err error) {
return c.DescribeClassicalLBTargetsWithContext(context.Background(), request)
}
// DescribeClassicalLBTargets
// DescribeClassicalLBTargets用于获取传统型负载均衡绑定的后端服务。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClassicalLBTargetsWithContext(ctx context.Context, request *DescribeClassicalLBTargetsRequest) (response *DescribeClassicalLBTargetsResponse, err error) {
if request == nil {
request = NewDescribeClassicalLBTargetsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeClassicalLBTargets require credential")
}
request.SetContext(ctx)
response = NewDescribeClassicalLBTargetsResponse()
err = c.Send(request, response)
return
}
func NewDescribeClsLogSetRequest() (request *DescribeClsLogSetRequest) {
request = &DescribeClsLogSetRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeClsLogSet")
return
}
func NewDescribeClsLogSetResponse() (response *DescribeClsLogSetResponse) {
response = &DescribeClsLogSetResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeClsLogSet
// 获取用户的CLB专有日志集。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClsLogSet(request *DescribeClsLogSetRequest) (response *DescribeClsLogSetResponse, err error) {
return c.DescribeClsLogSetWithContext(context.Background(), request)
}
// DescribeClsLogSet
// 获取用户的CLB专有日志集。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeClsLogSetWithContext(ctx context.Context, request *DescribeClsLogSetRequest) (response *DescribeClsLogSetResponse, err error) {
if request == nil {
request = NewDescribeClsLogSetRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeClsLogSet require credential")
}
request.SetContext(ctx)
response = NewDescribeClsLogSetResponse()
err = c.Send(request, response)
return
}
func NewDescribeClusterResourcesRequest() (request *DescribeClusterResourcesRequest) {
request = &DescribeClusterResourcesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeClusterResources")
return
}
func NewDescribeClusterResourcesResponse() (response *DescribeClusterResourcesResponse) {
response = &DescribeClusterResourcesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeClusterResources
// 查询独占集群中的资源列表，支持按集群ID、VIP、负载均衡ID、是否闲置为过滤条件检索。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
func (c *Client) DescribeClusterResources(request *DescribeClusterResourcesRequest) (response *DescribeClusterResourcesResponse, err error) {
return c.DescribeClusterResourcesWithContext(context.Background(), request)
}
// DescribeClusterResources
// 查询独占集群中的资源列表，支持按集群ID、VIP、负载均衡ID、是否闲置为过滤条件检索。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
func (c *Client) DescribeClusterResourcesWithContext(ctx context.Context, request *DescribeClusterResourcesRequest) (response *DescribeClusterResourcesResponse, err error) {
if request == nil {
request = NewDescribeClusterResourcesRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeClusterResources require credential")
}
request.SetContext(ctx)
response = NewDescribeClusterResourcesResponse()
err = c.Send(request, response)
return
}
func NewDescribeCrossTargetsRequest() (request *DescribeCrossTargetsRequest) {
request = &DescribeCrossTargetsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeCrossTargets")
return
}
func NewDescribeCrossTargetsResponse() (response *DescribeCrossTargetsResponse) {
response = &DescribeCrossTargetsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeCrossTargets
// 查询跨域2.0版本云联网后端子机和网卡信息。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCrossTargets(request *DescribeCrossTargetsRequest) (response *DescribeCrossTargetsResponse, err error) {
return c.DescribeCrossTargetsWithContext(context.Background(), request)
}
// DescribeCrossTargets
// 查询跨域2.0版本云联网后端子机和网卡信息。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCrossTargetsWithContext(ctx context.Context, request *DescribeCrossTargetsRequest) (response *DescribeCrossTargetsResponse, err error) {
if request == nil {
request = NewDescribeCrossTargetsRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeCrossTargets require credential")
}
request.SetContext(ctx)
response = NewDescribeCrossTargetsResponse()
err = c.Send(request, response)
return
}
func NewDescribeCustomizedConfigAssociateListRequest() (request *DescribeCustomizedConfigAssociateListRequest) {
request = &DescribeCustomizedConfigAssociateListRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeCustomizedConfigAssociateList")
return
}
func NewDescribeCustomizedConfigAssociateListResponse() (response *DescribeCustomizedConfigAssociateListResponse) {
response = &DescribeCustomizedConfigAssociateListResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeCustomizedConfigAssociateList
// 拉取配置绑定的 server 或 location，如果 domain 存在，结果将根据 domain 过滤。或拉取配置绑定的 loadbalancer。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCustomizedConfigAssociateList(request *DescribeCustomizedConfigAssociateListRequest) (response *DescribeCustomizedConfigAssociateListResponse, err error) {
return c.DescribeCustomizedConfigAssociateListWithContext(context.Background(), request)
}
// DescribeCustomizedConfigAssociateList
// 拉取配置绑定的 server 或 location，如果 domain 存在，结果将根据 domain 过滤。或拉取配置绑定的 loadbalancer。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCustomizedConfigAssociateListWithContext(ctx context.Context, request *DescribeCustomizedConfigAssociateListRequest) (response *DescribeCustomizedConfigAssociateListResponse, err error) {
if request == nil {
request = NewDescribeCustomizedConfigAssociateListRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeCustomizedConfigAssociateList require credential")
}
request.SetContext(ctx)
response = NewDescribeCustomizedConfigAssociateListResponse()
err = c.Send(request, response)
return
}
func NewDescribeCustomizedConfigListRequest() (request *DescribeCustomizedConfigListRequest) {
request = &DescribeCustomizedConfigListRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeCustomizedConfigList")
return
}
func NewDescribeCustomizedConfigListResponse() (response *DescribeCustomizedConfigListResponse) {
response = &DescribeCustomizedConfigListResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeCustomizedConfigList
// 拉取个性化配置列表，返回用户 AppId 下指定类型的配置。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETER_REWRITEALREADYEXIST = "InvalidParameter.RewriteAlreadyExist"
// INVALIDPARAMETER_SOMEREWRITENOTFOUND = "InvalidParameter.SomeRewriteNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCustomizedConfigList(request *DescribeCustomizedConfigListRequest) (response *DescribeCustomizedConfigListResponse, err error) {
return c.DescribeCustomizedConfigListWithContext(context.Background(), request)
}
// DescribeCustomizedConfigList
// 拉取个性化配置列表，返回用户 AppId 下指定类型的配置。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETER_PROTOCOLCHECKFAILED = "InvalidParameter.ProtocolCheckFailed"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETER_REWRITEALREADYEXIST = "InvalidParameter.RewriteAlreadyExist"
// INVALIDPARAMETER_SOMEREWRITENOTFOUND = "InvalidParameter.SomeRewriteNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// RESOURCEINSUFFICIENT = "ResourceInsufficient"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCustomizedConfigListWithContext(ctx context.Context, request *DescribeCustomizedConfigListRequest) (response *DescribeCustomizedConfigListResponse, err error) {
if request == nil {
request = NewDescribeCustomizedConfigListRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeCustomizedConfigList require credential")
}
request.SetContext(ctx)
response = NewDescribeCustomizedConfigListResponse()
err = c.Send(request, response)
return
}
func NewDescribeExclusiveClustersRequest() (request *DescribeExclusiveClustersRequest) {
request = &DescribeExclusiveClustersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeExclusiveClusters")
return
}
func NewDescribeExclusiveClustersResponse() (response *DescribeExclusiveClustersResponse) {
response = &DescribeExclusiveClustersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeExclusiveClusters
// 查询集群信息列表，支持以集群类型、集群唯一ID、集群名字、集群标签、集群内vip、集群内负载均衡唯一id、集群网络类型、可用区等条件进行检索
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
func (c *Client) DescribeExclusiveClusters(request *DescribeExclusiveClustersRequest) (response *DescribeExclusiveClustersResponse, err error) {
return c.DescribeExclusiveClustersWithContext(context.Background(), request)
}
// DescribeExclusiveClusters
// 查询集群信息列表，支持以集群类型、集群唯一ID、集群名字、集群标签、集群内vip、集群内负载均衡唯一id、集群网络类型、可用区等条件进行检索
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_DUPLICATE = "InvalidParameterValue.Duplicate"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
func (c *Client) DescribeExclusiveClustersWithContext(ctx context.Context, request *DescribeExclusiveClustersRequest) (response *DescribeExclusiveClustersResponse, err error) {
if request == nil {
request = NewDescribeExclusiveClustersRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeExclusiveClusters require credential")
}
request.SetContext(ctx)
response = NewDescribeExclusiveClustersResponse()
err = c.Send(request, response)
return
}
func NewDescribeIdleLoadBalancersRequest() (request *DescribeIdleLoadBalancersRequest) {
request = &DescribeIdleLoadBalancersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeIdleLoadBalancers")
return
}
func NewDescribeIdleLoadBalancersResponse() (response *DescribeIdleLoadBalancersResponse) {
response = &DescribeIdleLoadBalancersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeIdleLoadBalancers
// 闲置实例是指创建超过7天后付费实例，且没有创建规则或创建规则没有绑定子机的负载均衡实例。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// DRYRUNOPERATION = "DryRunOperation"
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_INVALIDFILTER = "InvalidParameter.InvalidFilter"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
func (c *Client) DescribeIdleLoadBalancers(request *DescribeIdleLoadBalancersRequest) (response *DescribeIdleLoadBalancersResponse, err error) {
return c.DescribeIdleLoadBalancersWithContext(context.Background(), request)
}
// DescribeIdleLoadBalancers
// 闲置实例是指创建超过7天后付费实例，且没有创建规则或创建规则没有绑定子机的负载均衡实例。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// DRYRUNOPERATION = "DryRunOperation"
// FAILEDOPERATION = "FailedOperation"
// FAILEDOPERATION_INVALIDLBSTATUS = "FailedOperation.InvalidLBStatus"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_INVALIDFILTER = "InvalidParameter.InvalidFilter"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETER_LOCATIONNOTFOUND = "InvalidParameter.LocationNotFound"
// INVALIDPARAMETER_PORTCHECKFAILED = "InvalidParameter.PortCheckFailed"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
func (c *Client) DescribeIdleLoadBalancersWithContext(ctx context.Context, request *DescribeIdleLoadBalancersRequest) (response *DescribeIdleLoadBalancersResponse, err error) {
if request == nil {
request = NewDescribeIdleLoadBalancersRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeIdleLoadBalancers require credential")
}
request.SetContext(ctx)
response = NewDescribeIdleLoadBalancersResponse()
err = c.Send(request, response)
return
}
func NewDescribeLBListenersRequest() (request *DescribeLBListenersRequest) {
request = &DescribeLBListenersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeLBListeners")
return
}
func NewDescribeLBListenersResponse() (response *DescribeLBListenersResponse) {
response = &DescribeLBListenersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeLBListeners
// 查询后端云主机或弹性网卡绑定的负载均衡，支持弹性网卡和cvm查询。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeLBListeners(request *DescribeLBListenersRequest) (response *DescribeLBListenersResponse, err error) {
return c.DescribeLBListenersWithContext(context.Background(), request)
}
// DescribeLBListeners
// 查询后端云主机或弹性网卡绑定的负载均衡，支持弹性网卡和cvm查询。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_LISTENERIDNOTFOUND = "InvalidParameter.ListenerIdNotFound"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// LIMITEXCEEDED = "LimitExceeded"
// MISSINGPARAMETER = "MissingParameter"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeLBListenersWithContext(ctx context.Context, request *DescribeLBListenersRequest) (response *DescribeLBListenersResponse, err error) {
if request == nil {
request = NewDescribeLBListenersRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeLBListeners require credential")
}
request.SetContext(ctx)
response = NewDescribeLBListenersResponse()
err = c.Send(request, response)
return
}
func NewDescribeListenersRequest() (request *DescribeListenersRequest) {
request = &DescribeListenersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeListeners")
return
}
func NewDescribeListenersResponse() (response *DescribeListenersResponse) {
response = &DescribeListenersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeListeners
// DescribeListeners 接口可根据负载均衡器 ID、监听器的协议或端口作为过滤条件获取监听器列表。如果不指定任何过滤条件，则返回该负载均衡实例下的所有监听器。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeListeners(request *DescribeListenersRequest) (response *DescribeListenersResponse, err error) {
return c.DescribeListenersWithContext(context.Background(), request)
}
// DescribeListeners
// DescribeListeners 接口可根据负载均衡器 ID、监听器的协议或端口作为过滤条件获取监听器列表。如果不指定任何过滤条件，则返回该负载均衡实例下的所有监听器。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_LBIDNOTFOUND = "InvalidParameter.LBIdNotFound"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeListenersWithContext(ctx context.Context, request *DescribeListenersRequest) (response *DescribeListenersResponse, err error) {
if request == nil {
request = NewDescribeListenersRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeListeners require credential")
}
request.SetContext(ctx)
response = NewDescribeListenersResponse()
err = c.Send(request, response)
return
}
func NewDescribeLoadBalancerListByCertIdRequest() (request *DescribeLoadBalancerListByCertIdRequest) {
request = &DescribeLoadBalancerListByCertIdRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeLoadBalancerListByCertId")
return
}
func NewDescribeLoadBalancerListByCertIdResponse() (response *DescribeLoadBalancerListByCertIdResponse) {
response = &DescribeLoadBalancerListByCertIdResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeLoadBalancerListByCertId
// 根据证书ID查询其在一个地域中所关联到负载均衡实例列表
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeLoadBalancerListByCertId(request *DescribeLoadBalancerListByCertIdRequest) (response *DescribeLoadBalancerListByCertIdResponse, err error) {
return c.DescribeLoadBalancerListByCertIdWithContext(context.Background(), request)
}
// DescribeLoadBalancerListByCertId
// 根据证书ID查询其在一个地域中所关联到负载均衡实例列表
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeLoadBalancerListByCertIdWithContext(ctx context.Context, request *DescribeLoadBalancerListByCertIdRequest) (response *DescribeLoadBalancerListByCertIdResponse, err error) {
if request == nil {
request = NewDescribeLoadBalancerListByCertIdRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeLoadBalancerListByCertId require credential")
}
request.SetContext(ctx)
response = NewDescribeLoadBalancerListByCertIdResponse()
err = c.Send(request, response)
return
}
func NewDescribeLoadBalancerOverviewRequest() (request *DescribeLoadBalancerOverviewRequest) {
request = &DescribeLoadBalancerOverviewRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeLoadBalancerOverview")
return
}
func NewDescribeLoadBalancerOverviewResponse() (response *DescribeLoadBalancerOverviewResponse) {
response = &DescribeLoadBalancerOverviewResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeLoadBalancerOverview
// 查询运行中、隔离中、即将到期和负载均衡总数。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// DRYRUNOPERATION = "DryRunOperation"
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
func (c *Client) DescribeLoadBalancerOverview(request *DescribeLoadBalancerOverviewRequest) (response *DescribeLoadBalancerOverviewResponse, err error) {
return c.DescribeLoadBalancerOverviewWithContext(context.Background(), request)
}
// DescribeLoadBalancerOverview
// 查询运行中、隔离中、即将到期和负载均衡总数。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// DRYRUNOPERATION = "DryRunOperation"
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
func (c *Client) DescribeLoadBalancerOverviewWithContext(ctx context.Context, request *DescribeLoadBalancerOverviewRequest) (response *DescribeLoadBalancerOverviewResponse, err error) {
if request == nil {
request = NewDescribeLoadBalancerOverviewRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeLoadBalancerOverview require credential")
}
request.SetContext(ctx)
response = NewDescribeLoadBalancerOverviewResponse()
err = c.Send(request, response)
return
}
func NewDescribeLoadBalancerTrafficRequest() (request *DescribeLoadBalancerTrafficRequest) {
request = &DescribeLoadBalancerTrafficRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeLoadBalancerTraffic")
return
}
func NewDescribeLoadBalancerTrafficResponse() (response *DescribeLoadBalancerTrafficResponse) {
response = &DescribeLoadBalancerTrafficResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeLoadBalancerTraffic
// 查询账号下的高流量负载均衡，返回前10个负载均衡。如果是子账号登录，只返回子账号有权限的负载均衡。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
func (c *Client) DescribeLoadBalancerTraffic(request *DescribeLoadBalancerTrafficRequest) (response *DescribeLoadBalancerTrafficResponse, err error) {
return c.DescribeLoadBalancerTrafficWithContext(context.Background(), request)
}
// DescribeLoadBalancerTraffic
// 查询账号下的高流量负载均衡，返回前10个负载均衡。如果是子账号登录，只返回子账号有权限的负载均衡。
//
// 可能返回的错误码:
// AUTHFAILURE = "AuthFailure"
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
func (c *Client) DescribeLoadBalancerTrafficWithContext(ctx context.Context, request *DescribeLoadBalancerTrafficRequest) (response *DescribeLoadBalancerTrafficResponse, err error) {
if request == nil {
request = NewDescribeLoadBalancerTrafficRequest()
}
if c.GetCredential() == nil {
return nil, errors.New("DescribeLoadBalancerTraffic require credential")
}
request.SetContext(ctx)
response = NewDescribeLoadBalancerTrafficResponse()
err = c.Send(request, response)
return
}
func NewDescribeLoadBalancersRequest() (request *DescribeLoadBalancersRequest) {
request = &DescribeLoadBalancersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("clb", APIVersion, "DescribeLoadBalancers")
return
}
func NewDescribeLoadBalancersResponse() (response *DescribeLoadBalancersResponse) {
response = &DescribeLoadBalancersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// DescribeLoadBalancers
// 查询一个地域的负载均衡实例列表。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
// UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeLoadBalancers(request *DescribeLoadBalancersRequest) (response *DescribeLoadBalancersResponse, err error) {
return c.DescribeLoadBalancersWithContext(context.Background(), request)
}
// DescribeLoadBalancers
// 查询一个地域的负载均衡实例列表。
//
// 可能返回的错误码:
// FAILEDOPERATION = "FailedOperation"
// INTERNALERROR = "InternalError"
// INVALIDPARAMETER = "InvalidParameter"
// INVALIDPARAMETER_FORMATERROR = "InvalidParameter.FormatError"
// INVALIDPARAMETER_REGIONNOTFOUND = "InvalidParameter.RegionNotFound"
// INVALIDPARAMETERVALUE = "InvalidParameterValue"
// INVALIDPARAMETERVALUE_INVALIDFILTER = "InvalidParameterValue.InvalidFilter"
// INVALIDPARAMETERVALUE_LENGTH = "InvalidParameterValue.Length"
// INVALIDPARAMETERVALUE_RANGE = "InvalidParameterValue.Range"
// UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
// UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) De