model

package
v0.0.21-beta Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 12, 2020 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause Imports: 5 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AllQuotas 

type AllQuotas struct {
	// 配额详情资源列表。
	Resources *[]AllResources `json:"resources,omitempty"`
}

配额列表

func (AllQuotas) String 

func (o AllQuotas) String() string

type AllResources 

type AllResources struct {
	// 查询配额的类型。scaling_Group：伸缩组配额。scaling_Config：伸缩配置配额。scaling_Policy：伸缩策略配额。scaling_Instance：伸缩实例配额。bandwidth_scaling_policy：伸缩带宽策略配额。
	Type *AllResourcesType `json:"type,omitempty"`
	// 已使用的配额数量。当type为scaling_Policy和scaling_Instance时，该字段为保留字段，返回-1。可通过查询弹性伸缩策略和伸缩实例配额查询指定弹性伸缩组下的弹性伸缩策略和伸缩实例已使用的配额数量。
	Used *int32 `json:"used,omitempty"`
	// 配额总数量。
	Quota *int32 `json:"quota,omitempty"`
	// 配额上限。
	Max *int32 `json:"max,omitempty"`
}

配额资源

func (AllResources) String 

func (o AllResources) String() string

type AllResourcesType 

type AllResourcesType struct {
	// contains filtered or unexported fields
}

func (AllResourcesType) MarshalJSON 

func (c AllResourcesType) MarshalJSON() ([]byte, error)

func (*AllResourcesType) UnmarshalJSON 

func (c *AllResourcesType) UnmarshalJSON(b []byte) error

type AllResourcesTypeEnum 

type AllResourcesTypeEnum struct {
	SCALING_GROUP            AllResourcesType
	SCALING_CONFIG           AllResourcesType
	SCALING_POLICY           AllResourcesType
	SCALING_INSTANCE         AllResourcesType
	BANDWIDTH_SCALING_POLICY AllResourcesType
}

func GetAllResourcesTypeEnum 

func GetAllResourcesTypeEnum() AllResourcesTypeEnum

type Bandwidth 

type Bandwidth struct {
	// 带宽（Mbit/s），取值范围为[1,300]。
	Size int32 `json:"size"`
	// 带宽的共享类型。共享类型枚举：PER：独享型。WHOLE：共享型。
	ShareType *BandwidthShareType `json:"share_type,omitempty"`
	// 带宽的计费类型。字段值为“bandwidth”，表示按带宽计费。字段值为“traffic”，表示按流量计费。字段为其它值，会导致创建云服务器失败。如果share_type是PER，该参数为必选项。如果share_type是WHOLE，会忽略该参数。
	ChargingMode BandwidthChargingMode `json:"charging_mode"`
	// 带宽ID，使用共享型带宽时，可以选择之前创建的共享带宽来创建弹性IP。如果share_type是PER，会忽略该参数。如果share_type是WHOLE，该参数为必选项。
	Id *string `json:"id,omitempty"`
}

带宽信息

func (Bandwidth) String 

func (o Bandwidth) String() string

type BandwidthChargingMode 

type BandwidthChargingMode struct {
	// contains filtered or unexported fields
}

func (BandwidthChargingMode) MarshalJSON 

func (c BandwidthChargingMode) MarshalJSON() ([]byte, error)

func (*BandwidthChargingMode) UnmarshalJSON 

func (c *BandwidthChargingMode) UnmarshalJSON(b []byte) error

type BandwidthChargingModeEnum 

type BandwidthChargingModeEnum struct {
	BANDWIDTH BandwidthChargingMode
	TRAFFIC   BandwidthChargingMode
}

func GetBandwidthChargingModeEnum 

func GetBandwidthChargingModeEnum() BandwidthChargingModeEnum

type BandwidthShareType 

type BandwidthShareType struct {
	// contains filtered or unexported fields
}

func (BandwidthShareType) MarshalJSON 

func (c BandwidthShareType) MarshalJSON() ([]byte, error)

func (*BandwidthShareType) UnmarshalJSON 

func (c *BandwidthShareType) UnmarshalJSON(b []byte) error

type BandwidthShareTypeEnum 

type BandwidthShareTypeEnum struct {
	PER   BandwidthShareType
	WHOLE BandwidthShareType
}

func GetBandwidthShareTypeEnum 

func GetBandwidthShareTypeEnum() BandwidthShareTypeEnum

type BatchDeleteScalingConfigsRequest 

type BatchDeleteScalingConfigsRequest struct {
	Body *BatchDeleteScalingConfigsRequestBody `json:"body,omitempty"`
}

Request Object

func (BatchDeleteScalingConfigsRequest) String 

func (o BatchDeleteScalingConfigsRequest) String() string

type BatchDeleteScalingConfigsRequestBody 

type BatchDeleteScalingConfigsRequestBody struct {
	// 伸缩配置ID。
	ScalingConfigurationId *[]string `json:"scaling_configuration_id,omitempty"`
}

批量删除伸缩配置请求

func (BatchDeleteScalingConfigsRequestBody) String 

func (o BatchDeleteScalingConfigsRequestBody) String() string

type BatchDeleteScalingConfigsResponse 

type BatchDeleteScalingConfigsResponse struct {
}

Response Object

func (BatchDeleteScalingConfigsResponse) String 

func (o BatchDeleteScalingConfigsResponse) String() string

type CompleteLifecycleActionRequest 

type CompleteLifecycleActionRequest struct {
	ScalingGroupId string                              `json:"scaling_group_id"`
	Body           *CompleteLifecycleActionRequestBody `json:"body,omitempty"`
}

Request Object

func (CompleteLifecycleActionRequest) String 

func (o CompleteLifecycleActionRequest) String() string

type CompleteLifecycleActionRequestBody 

type CompleteLifecycleActionRequestBody struct {
	// 生命周期操作令牌，通过查询伸缩实例挂起信息接口获取。指定生命周期回调对象，当不传入instance_id字段时，该字段为必选。当该字段与instance_id字段都传入，优先使用该字段进行回调。
	LifecycleActionKey *string `json:"lifecycle_action_key,omitempty"`
	// 实例ID。指定生命周期回调对象，当不传入lifecycle_action_key字段时，该字段为必选。
	InstanceId *string `json:"instance_id,omitempty"`
	// 生命周期挂钩名称。指定生命周期回调对象，当不传入lifecycle_action_key字段时，该字段为必选。
	LifecycleHookName *string `json:"lifecycle_hook_name,omitempty"`
	// 生命周期回调操作。ABANDON：终止。CONTINUE：继续。EXTEND：延长超时时间，每次延长1小时。
	LifecycleActionResult CompleteLifecycleActionRequestBodyLifecycleActionResult `json:"lifecycle_action_result"`
}

伸缩实例生命周期回调

func (CompleteLifecycleActionRequestBody) String 

func (o CompleteLifecycleActionRequestBody) String() string

type CompleteLifecycleActionRequestBodyLifecycleActionResult 

type CompleteLifecycleActionRequestBodyLifecycleActionResult struct {
	// contains filtered or unexported fields
}

func (CompleteLifecycleActionRequestBodyLifecycleActionResult) MarshalJSON 

func (c CompleteLifecycleActionRequestBodyLifecycleActionResult) MarshalJSON() ([]byte, error)

func (*CompleteLifecycleActionRequestBodyLifecycleActionResult) UnmarshalJSON 

func (c *CompleteLifecycleActionRequestBodyLifecycleActionResult) UnmarshalJSON(b []byte) error

type CompleteLifecycleActionRequestBodyLifecycleActionResultEnum 

type CompleteLifecycleActionRequestBodyLifecycleActionResultEnum struct {
	ABANDON  CompleteLifecycleActionRequestBodyLifecycleActionResult
	CONTINUE CompleteLifecycleActionRequestBodyLifecycleActionResult
	EXTEND   CompleteLifecycleActionRequestBodyLifecycleActionResult
}

func GetCompleteLifecycleActionRequestBodyLifecycleActionResultEnum 

func GetCompleteLifecycleActionRequestBodyLifecycleActionResultEnum() CompleteLifecycleActionRequestBodyLifecycleActionResultEnum

type CompleteLifecycleActionResponse 

type CompleteLifecycleActionResponse struct {
}

Response Object

func (CompleteLifecycleActionResponse) String 

func (o CompleteLifecycleActionResponse) String() string

type CreateLifeCycleHookRequestBody 

type CreateLifeCycleHookRequestBody struct {
	// 生命周期挂钩名称(1-32个字符)，只能包含字母、数字、下划线或中划线。
	LifecycleHookName string `json:"lifecycle_hook_name"`
	// 生命周期挂钩类型。INSTANCE_TERMINATING。INSTANCE_LAUNCHING。INSTANCE_TERMINATING 类型的挂钩负责在实例终止时将实例挂起，INSTANCE_LAUNCHING 类型的挂钩则是在实例启动时将实例挂起。
	LifecycleHookType CreateLifeCycleHookRequestBodyLifecycleHookType `json:"lifecycle_hook_type"`
	// 生命周期挂钩默认回调操作。默认情况下，到达超时时间后执行的操作。ABANDON；CONTINUE；如果实例正在启动，则 CONTINUE 表示用户自定义操作已成功，可将实例投入使用。否则，ABANDON 表示用户自定义操作未成功，终止实例，伸缩活动置为失败，重新创建新实例。如果实例正在终止，则 ABANDON 和 CONTINUE 都允许终止实例。不过，ABANDON 将停止其他生命周期挂钩，而 CONTINUE 将允许完成其他生命周期挂钩。该字段缺省时默认为 ABANDON。
	DefaultResult *CreateLifeCycleHookRequestBodyDefaultResult `json:"default_result,omitempty"`
	// 生命周期挂钩超时时间，取值范围300-86400，默认为3600，单位是秒。默认情况下，实例保持等待状态的时间。您可以延长超时时间，也可以在超时时间结束前进行 CONTINUE 或 ABANDON 操作。
	DefaultTimeout *int32 `json:"default_timeout,omitempty"`
	// SMN 服务中 Topic 的唯一的资源标识。为生命周期挂钩定义一个通知目标，当实例被生命周期挂钩挂起时向该通知目标发送消息。该消息包含实例的基本信息、用户自定义通知消息，以及可用于控制生命周期操作的令牌信息。
	NotificationTopicUrn string `json:"notification_topic_urn"`
	// 自定义通知消息，长度不超过256位，不能包含字符< > & ' ( )当配置了通知目标时，可向其发送用户自定义的通知内容。
	NotificationMetadata *string `json:"notification_metadata,omitempty"`
}

创建生命周期挂钩

func (CreateLifeCycleHookRequestBody) String 

func (o CreateLifeCycleHookRequestBody) String() string

type CreateLifeCycleHookRequestBodyDefaultResult 

type CreateLifeCycleHookRequestBodyDefaultResult struct {
	// contains filtered or unexported fields
}

func (CreateLifeCycleHookRequestBodyDefaultResult) MarshalJSON 

func (c CreateLifeCycleHookRequestBodyDefaultResult) MarshalJSON() ([]byte, error)

func (*CreateLifeCycleHookRequestBodyDefaultResult) UnmarshalJSON 

func (c *CreateLifeCycleHookRequestBodyDefaultResult) UnmarshalJSON(b []byte) error

type CreateLifeCycleHookRequestBodyDefaultResultEnum 

type CreateLifeCycleHookRequestBodyDefaultResultEnum struct {
	ABANDON  CreateLifeCycleHookRequestBodyDefaultResult
	CONTINUE CreateLifeCycleHookRequestBodyDefaultResult
}

func GetCreateLifeCycleHookRequestBodyDefaultResultEnum 

func GetCreateLifeCycleHookRequestBodyDefaultResultEnum() CreateLifeCycleHookRequestBodyDefaultResultEnum

type CreateLifeCycleHookRequestBodyLifecycleHookType 

type CreateLifeCycleHookRequestBodyLifecycleHookType struct {
	// contains filtered or unexported fields
}

func (CreateLifeCycleHookRequestBodyLifecycleHookType) MarshalJSON 

func (c CreateLifeCycleHookRequestBodyLifecycleHookType) MarshalJSON() ([]byte, error)

func (*CreateLifeCycleHookRequestBodyLifecycleHookType) UnmarshalJSON 

func (c *CreateLifeCycleHookRequestBodyLifecycleHookType) UnmarshalJSON(b []byte) error

type CreateLifeCycleHookRequestBodyLifecycleHookTypeEnum 

type CreateLifeCycleHookRequestBodyLifecycleHookTypeEnum struct {
	INSTANCE_TERMINATING CreateLifeCycleHookRequestBodyLifecycleHookType
	INSTANCE_LAUNCHING   CreateLifeCycleHookRequestBodyLifecycleHookType
}

func GetCreateLifeCycleHookRequestBodyLifecycleHookTypeEnum 

func GetCreateLifeCycleHookRequestBodyLifecycleHookTypeEnum() CreateLifeCycleHookRequestBodyLifecycleHookTypeEnum

type CreateLifyCycleHookRequest 

type CreateLifyCycleHookRequest struct {
	ScalingGroupId string                          `json:"scaling_group_id"`
	Body           *CreateLifeCycleHookRequestBody `json:"body,omitempty"`
}

Request Object

func (CreateLifyCycleHookRequest) String 

func (o CreateLifyCycleHookRequest) String() string

type CreateLifyCycleHookResponse 

type CreateLifyCycleHookResponse struct {
	// 生命周期挂钩名称。
	LifecycleHookName *string `json:"lifecycle_hook_name,omitempty"`
	// 生命周期挂钩类型。INSTANCE_TERMINATING;INSTANCE_LAUNCHING
	LifecycleHookType *CreateLifyCycleHookResponseLifecycleHookType `json:"lifecycle_hook_type,omitempty"`
	// 生命周期挂钩默认回调操作。ABANDON;CONTINUE
	DefaultResult *CreateLifyCycleHookResponseDefaultResult `json:"default_result,omitempty"`
	// 生命周期挂钩超时时间，单位秒。
	DefaultTimeout *int32 `json:"default_timeout,omitempty"`
	// SMN服务中Topic的唯一的资源标识。
	NotificationTopicUrn *string `json:"notification_topic_urn,omitempty"`
	// SMN服务中Topic的资源名称。
	NotificationTopicName *string `json:"notification_topic_name,omitempty"`
	// 自定义通知消息。
	NotificationMetadata *string `json:"notification_metadata,omitempty"`
	// 生命周期挂钩创建时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
}

Response Object

func (CreateLifyCycleHookResponse) String 

func (o CreateLifyCycleHookResponse) String() string

type CreateLifyCycleHookResponseDefaultResult 

type CreateLifyCycleHookResponseDefaultResult struct {
	// contains filtered or unexported fields
}

func (CreateLifyCycleHookResponseDefaultResult) MarshalJSON 

func (c CreateLifyCycleHookResponseDefaultResult) MarshalJSON() ([]byte, error)

func (*CreateLifyCycleHookResponseDefaultResult) UnmarshalJSON 

func (c *CreateLifyCycleHookResponseDefaultResult) UnmarshalJSON(b []byte) error

type CreateLifyCycleHookResponseDefaultResultEnum 

type CreateLifyCycleHookResponseDefaultResultEnum struct {
	ABANDON  CreateLifyCycleHookResponseDefaultResult
	CONTINUE CreateLifyCycleHookResponseDefaultResult
}

func GetCreateLifyCycleHookResponseDefaultResultEnum 

func GetCreateLifyCycleHookResponseDefaultResultEnum() CreateLifyCycleHookResponseDefaultResultEnum

type CreateLifyCycleHookResponseLifecycleHookType 

type CreateLifyCycleHookResponseLifecycleHookType struct {
	// contains filtered or unexported fields
}

func (CreateLifyCycleHookResponseLifecycleHookType) MarshalJSON 

func (c CreateLifyCycleHookResponseLifecycleHookType) MarshalJSON() ([]byte, error)

func (*CreateLifyCycleHookResponseLifecycleHookType) UnmarshalJSON 

func (c *CreateLifyCycleHookResponseLifecycleHookType) UnmarshalJSON(b []byte) error

type CreateLifyCycleHookResponseLifecycleHookTypeEnum 

type CreateLifyCycleHookResponseLifecycleHookTypeEnum struct {
	INSTANCE_TERMINATING CreateLifyCycleHookResponseLifecycleHookType
	INSTANCE_LAUNCHING   CreateLifyCycleHookResponseLifecycleHookType
}

func GetCreateLifyCycleHookResponseLifecycleHookTypeEnum 

func GetCreateLifyCycleHookResponseLifecycleHookTypeEnum() CreateLifyCycleHookResponseLifecycleHookTypeEnum

type CreateNotificationRequestBody 

type CreateNotificationRequestBody struct {
	// SMN服务中Topic的唯一的资源标识。
	TopicUrn *string `json:"topic_urn,omitempty"`
	// 通知场景，有以下五种类型。SCALING_UP：扩容成功。SCALING_UP_FAIL：扩容失败。SCALING_DOWN：减容成功。SCALING_DOWN_FAIL：减容失败。SCALING_GROUP_ABNORMAL：伸缩组发生异常
	TopicScene *[]string `json:"topic_scene,omitempty"`
}

配置伸缩组通知

func (CreateNotificationRequestBody) String 

func (o CreateNotificationRequestBody) String() string

type CreateScalingConfigRequest 

type CreateScalingConfigRequest struct {
	Body *CreateScalingConfigRequestBody `json:"body,omitempty"`
}

Request Object

func (CreateScalingConfigRequest) String 

func (o CreateScalingConfigRequest) String() string

type CreateScalingConfigRequestBody 

type CreateScalingConfigRequestBody struct {
	// 伸缩配置名称(1-64个字符)，只能包含中文、字母、数字、下划线或中划线。
	ScalingConfigurationName string          `json:"scaling_configuration_name"`
	InstanceConfig           *InstanceConfig `json:"instance_config"`
}

创建伸缩配置请求

func (CreateScalingConfigRequestBody) String 

func (o CreateScalingConfigRequestBody) String() string

type CreateScalingConfigResponse 

type CreateScalingConfigResponse struct {
	// 伸缩配置ID
	ScalingConfigurationId *string `json:"scaling_configuration_id,omitempty"`
}

Response Object

func (CreateScalingConfigResponse) String 

func (o CreateScalingConfigResponse) String() string

type CreateScalingGroupRequest 

type CreateScalingGroupRequest struct {
	Body *CreateScalingGroupRequestBody `json:"body,omitempty"`
}

Request Object

func (CreateScalingGroupRequest) String 

func (o CreateScalingGroupRequest) String() string

type CreateScalingGroupRequestBody 

type CreateScalingGroupRequestBody struct {
	// 伸缩组名称(1-64个字符)，只能包含中文、字母、数字、下划线、中划线。
	ScalingGroupName string `json:"scaling_group_name"`
	// 伸缩配置ID，通过查询弹性伸缩配置列表接口获取。
	ScalingConfigurationId *string `json:"scaling_configuration_id,omitempty"`
	// 期望实例数量，默认值为最小实例数。最小实例数<=期望实例数<=最大实例数
	DesireInstanceNumber *int32 `json:"desire_instance_number,omitempty"`
	// 最小实例数量，默认值为0。
	MinInstanceNumber *int32 `json:"min_instance_number,omitempty"`
	// 最大实例数量，默认值为0。
	MaxInstanceNumber *int32 `json:"max_instance_number,omitempty"`
	// 冷却时间，取值范围0-86400，默认为900，单位是秒。 只针对告警策略生效，定时、周期策略和手动触发策略不受该参数限制。
	CoolDownTime *int32 `json:"cool_down_time,omitempty"`
	// 弹性负载均衡（经典型）监听器ID，最多支持绑定3个负载均衡监听器，多个负载均衡监听器ID以逗号分隔。首先使用vpc_id通过查询ELB服务负载均衡器列表接口获取负载均衡器的ID，详见《弹性负载均衡API参考》的“查询负载均衡器列表”，再使用该ID查询监听器列表获取，详见《弹性负载均衡API参考》的“查询监听器列表”。
	LbListenerId *string `json:"lb_listener_id,omitempty"`
	// 弹性负载均衡器（增强型）信息，最多支持绑定3个负载均衡。该字段与lb_listener_id互斥。
	LbaasListeners *[]LbaasListeners `json:"lbaas_listeners,omitempty"`
	// 可用分区信息。弹性伸缩活动中自动添加的云服务器会被创建在指定的可用区中。如果没有指定可用分区，会由系统自动指定可用分区。详情请参考地区和终端节点。
	AvailableZones *[]string `json:"available_zones,omitempty"`
	// 网络信息，最多支持选择5个子网，传入的第一个子网默认作为云服务器的主网卡。使用vpc_id通过查询VPC服务子网列表接口获取， 查询子网列表”。
	Networks []Networks `json:"networks"`
	// 安全组信息，最多支持选择1个安全组。使用vpc_id通过查询VPC服务安全组列表接口获取，详见《虚拟私有云API参考》的“查询安全组列表”。当伸缩配置和伸缩组同时指定安全组时，将以伸缩配置中的安全组为准；当伸缩配置和伸缩组都没有指定安全组时，将使用默认安全组。为了使用灵活性更高，推荐在伸缩配置中指定安全组。
	SecurityGroups *[]SecurityGroups `json:"security_groups,omitempty"`
	// VPC信息，通过查询VPC服务VPC列表接口获取，详见《虚拟私有云API参考》的“查询VPC列表”。
	VpcId string `json:"vpc_id"`
	// 伸缩组实例健康检查方式：ELB_AUDIT和NOVA_AUDIT。当伸缩组参数中设置负载均衡时，默认为ELB_AUDIT；否则默认为NOVA_AUDIT。ELB_AUDIT表示负载均衡健康检查方式，在有监听器的伸缩组中有效。NOVA_AUDIT表示弹性伸缩自带的健康检查方式。
	HealthPeriodicAuditMethod *CreateScalingGroupRequestBodyHealthPeriodicAuditMethod `json:"health_periodic_audit_method,omitempty"`
	// 伸缩组实例的健康检查周期，可设置为1、5、15、60、180（分钟），若不设置该参数，默认为5。若设置为0，可以实现10秒级健康检查。
	HealthPeriodicAuditTime *CreateScalingGroupRequestBodyHealthPeriodicAuditTime `json:"health_periodic_audit_time,omitempty"`
	// 伸缩组实例健康状况检查宽限期，取值范围0-86400，单位是秒。当实例加入伸缩组并且进入已启用状态后，健康状况检查宽限期才会启动，伸缩组会等健康状况检查宽限期结束后才检查实例的运行状况。当伸缩组实例健康检查方式为ELB_AUDIT时，该参数生效，若不设置该参数，默认为600秒。
	HealthPeriodicAuditGracePeriod *int32 `json:"health_periodic_audit_grace_period,omitempty"`
	// 伸缩组实例移除策略：OLD_CONFIG_OLD_INSTANCE（默认）：从根据“较早创建的配置”创建的实例中筛选出较早创建的实例被优先移除。OLD_CONFIG_NEW_INSTANCE：从根据“较早创建的配置”创建的实例中筛选出较新创建的实例被优先移除。OLD_INSTANCE：较早创建的实例被优先移除。NEW_INSTANCE：较新创建的实例将被优先移除。
	InstanceTerminatePolicy *CreateScalingGroupRequestBodyInstanceTerminatePolicy `json:"instance_terminate_policy,omitempty"`
	// 通知方式：EMAIL为发送邮件通知。该通知方式即将被废除，建议给弹性伸缩组配置通知功能。详见通知。
	Notifications *[]string `json:"notifications,omitempty"`
	// 配置删除云服务器时是否删除云服务器绑定的弹性IP。取值为true或false，默认为false。true：删除云服务器时，会同时删除绑定在云服务器上的弹性IP。当弹性IP的计费方式为包年包月时，不会被删除。false：删除云服务器时，仅解绑定在云服务器上的弹性IP，不删除弹性IP。
	DeletePublicip *bool `json:"delete_publicip,omitempty"`
	// 企业项目ID，用于指定伸缩组归属的企业项目。当伸缩组配置企业项目时，由该伸缩组创建的弹性云服务器将归属于该企业项目。当没有指定企业项目时，将使用企业项目ID为0的默认项目。
	EnterpriseProjectId *string `json:"enterprise_project_id,omitempty"`
	// 伸缩组扩缩容时目标AZ选择的优先级策略：EQUILIBRIUM_DISTRIBUTE（默认）：均衡分布，云服务器扩缩容时优先保证available_zones列表中各AZ下虚拟机数量均衡，当无法在目标AZ下完成虚拟机扩容时，按照PICK_FIRST原则选择其他可用AZ。PICK_FIRST：选择优先，虚拟机扩缩容时目标AZ的选择按照available_zones列表的顺序进行优先级排序。
	MultiAzPriorityPolicy *CreateScalingGroupRequestBodyMultiAzPriorityPolicy `json:"multi_az_priority_policy,omitempty"`
}

创建伸缩组请求

func (CreateScalingGroupRequestBody) String 

func (o CreateScalingGroupRequestBody) String() string

type CreateScalingGroupRequestBodyHealthPeriodicAuditMethod 

type CreateScalingGroupRequestBodyHealthPeriodicAuditMethod struct {
	// contains filtered or unexported fields
}

func (CreateScalingGroupRequestBodyHealthPeriodicAuditMethod) MarshalJSON 

func (c CreateScalingGroupRequestBodyHealthPeriodicAuditMethod) MarshalJSON() ([]byte, error)

func (*CreateScalingGroupRequestBodyHealthPeriodicAuditMethod) UnmarshalJSON 

func (c *CreateScalingGroupRequestBodyHealthPeriodicAuditMethod) UnmarshalJSON(b []byte) error

type CreateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum 

type CreateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum struct {
	ELB_AUDIT  CreateScalingGroupRequestBodyHealthPeriodicAuditMethod
	NOVA_AUDIT CreateScalingGroupRequestBodyHealthPeriodicAuditMethod
}

func GetCreateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum 

func GetCreateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum() CreateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum

type CreateScalingGroupRequestBodyHealthPeriodicAuditTime 

type CreateScalingGroupRequestBodyHealthPeriodicAuditTime struct {
	// contains filtered or unexported fields
}

func (CreateScalingGroupRequestBodyHealthPeriodicAuditTime) MarshalJSON 

func (c CreateScalingGroupRequestBodyHealthPeriodicAuditTime) MarshalJSON() ([]byte, error)

func (*CreateScalingGroupRequestBodyHealthPeriodicAuditTime) UnmarshalJSON 

func (c *CreateScalingGroupRequestBodyHealthPeriodicAuditTime) UnmarshalJSON(b []byte) error

type CreateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum 

type CreateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum struct {
	E_0   CreateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_1   CreateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_5   CreateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_15  CreateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_60  CreateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_180 CreateScalingGroupRequestBodyHealthPeriodicAuditTime
}

func GetCreateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum 

func GetCreateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum() CreateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum

type CreateScalingGroupRequestBodyInstanceTerminatePolicy 

type CreateScalingGroupRequestBodyInstanceTerminatePolicy struct {
	// contains filtered or unexported fields
}

func (CreateScalingGroupRequestBodyInstanceTerminatePolicy) MarshalJSON 

func (c CreateScalingGroupRequestBodyInstanceTerminatePolicy) MarshalJSON() ([]byte, error)

func (*CreateScalingGroupRequestBodyInstanceTerminatePolicy) UnmarshalJSON 

func (c *CreateScalingGroupRequestBodyInstanceTerminatePolicy) UnmarshalJSON(b []byte) error

type CreateScalingGroupRequestBodyInstanceTerminatePolicyEnum 

type CreateScalingGroupRequestBodyInstanceTerminatePolicyEnum struct {
	OLD_CONFIG_OLD_INSTANCE CreateScalingGroupRequestBodyInstanceTerminatePolicy
	OLD_CONFIG_NEW_INSTANCE CreateScalingGroupRequestBodyInstanceTerminatePolicy
	OLD_INSTANCE            CreateScalingGroupRequestBodyInstanceTerminatePolicy
	NEW_INSTANCE            CreateScalingGroupRequestBodyInstanceTerminatePolicy
}

func GetCreateScalingGroupRequestBodyInstanceTerminatePolicyEnum 

func GetCreateScalingGroupRequestBodyInstanceTerminatePolicyEnum() CreateScalingGroupRequestBodyInstanceTerminatePolicyEnum

type CreateScalingGroupRequestBodyMultiAzPriorityPolicy 

type CreateScalingGroupRequestBodyMultiAzPriorityPolicy struct {
	// contains filtered or unexported fields
}

func (CreateScalingGroupRequestBodyMultiAzPriorityPolicy) MarshalJSON 

func (c CreateScalingGroupRequestBodyMultiAzPriorityPolicy) MarshalJSON() ([]byte, error)

func (*CreateScalingGroupRequestBodyMultiAzPriorityPolicy) UnmarshalJSON 

func (c *CreateScalingGroupRequestBodyMultiAzPriorityPolicy) UnmarshalJSON(b []byte) error

type CreateScalingGroupRequestBodyMultiAzPriorityPolicyEnum 

type CreateScalingGroupRequestBodyMultiAzPriorityPolicyEnum struct {
	EQUILIBRIUM_DISTRIBUTE CreateScalingGroupRequestBodyMultiAzPriorityPolicy
	PICK_FIRST             CreateScalingGroupRequestBodyMultiAzPriorityPolicy
}

func GetCreateScalingGroupRequestBodyMultiAzPriorityPolicyEnum 

func GetCreateScalingGroupRequestBodyMultiAzPriorityPolicyEnum() CreateScalingGroupRequestBodyMultiAzPriorityPolicyEnum

type CreateScalingGroupResponse 

type CreateScalingGroupResponse struct {
	// 伸缩组ID
	ScalingGroupId *string `json:"scaling_group_id,omitempty"`
}

Response Object

func (CreateScalingGroupResponse) String 

func (o CreateScalingGroupResponse) String() string

type CreateScalingNotificationRequest 

type CreateScalingNotificationRequest struct {
	ScalingGroupId string                         `json:"scaling_group_id"`
	Body           *CreateNotificationRequestBody `json:"body,omitempty"`
}

Request Object

func (CreateScalingNotificationRequest) String 

func (o CreateScalingNotificationRequest) String() string

type CreateScalingNotificationResponse 

type CreateScalingNotificationResponse struct {
	// SMN服务中Topic的唯一的资源标识。
	TopicUrn *string `json:"topic_urn,omitempty"`
	// 通知场景，有以下五种类型。SCALING_UP：扩容成功。SCALING_UP_FAIL：扩容失败。SCALING_DOWN：减容成功。SCALING_DOWN_FAIL：减容失败。SCALING_GROUP_ABNORMAL：伸缩组发生异常
	TopicScene *[]string `json:"topic_scene,omitempty"`
	// SMN服务中Topic的资源名称。
	TopicName *string `json:"topic_name,omitempty"`
}

Response Object

func (CreateScalingNotificationResponse) String 

func (o CreateScalingNotificationResponse) String() string

type CreateScalingPolicyRequest 

type CreateScalingPolicyRequest struct {
	Body *CreateScalingPolicyRequestBody `json:"body,omitempty"`
}

Request Object

func (CreateScalingPolicyRequest) String 

func (o CreateScalingPolicyRequest) String() string

type CreateScalingPolicyRequestBody 

type CreateScalingPolicyRequestBody struct {
	// 策略名称(1-64字符)，可以用中文、字母、数字、下划线、中划线的组合。
	ScalingPolicyName string `json:"scaling_policy_name"`
	// 伸缩组ID，通过查询弹性伸缩组列表获取，详见查询弹性伸缩组列表。
	ScalingGroupId string `json:"scaling_group_id"`
	// 策略类型。告警策略：ALARM（与alarm_id对应）；定时策略：SCHEDULED（与scheduled_policy对应）；周期策略：RECURRENCE（与scheduled_policy对应）
	ScalingPolicyType CreateScalingPolicyRequestBodyScalingPolicyType `json:"scaling_policy_type"`
	// 告警ID，即告警规则的ID，当scaling_policy_type为ALARM时该项必选，此时scheduled_policy不生效。创建告警策略成功后，会自动为该告警ID对应的告警规则的alarm_actions字段增加类型为autoscaling的告警触发动作。告警ID通过查询云监控告警规则列表获取，详见《云监控API参考》的“查询告警规则列表”。
	AlarmId             *string              `json:"alarm_id,omitempty"`
	ScheduledPolicy     *ScheduledPolicy     `json:"scheduled_policy,omitempty"`
	ScalingPolicyAction *ScalingPolicyAction `json:"scaling_policy_action,omitempty"`
	// 冷却时间，取值范围0-86400，默认为900，单位是秒。
	CoolDownTime *int32 `json:"cool_down_time,omitempty"`
}

创建伸缩策略

func (CreateScalingPolicyRequestBody) String 

func (o CreateScalingPolicyRequestBody) String() string

type CreateScalingPolicyRequestBodyScalingPolicyType 

type CreateScalingPolicyRequestBodyScalingPolicyType struct {
	// contains filtered or unexported fields
}

func (CreateScalingPolicyRequestBodyScalingPolicyType) MarshalJSON 

func (c CreateScalingPolicyRequestBodyScalingPolicyType) MarshalJSON() ([]byte, error)

func (*CreateScalingPolicyRequestBodyScalingPolicyType) UnmarshalJSON 

func (c *CreateScalingPolicyRequestBodyScalingPolicyType) UnmarshalJSON(b []byte) error

type CreateScalingPolicyRequestBodyScalingPolicyTypeEnum 

type CreateScalingPolicyRequestBodyScalingPolicyTypeEnum struct {
	ALARM      CreateScalingPolicyRequestBodyScalingPolicyType
	SCHEDULED  CreateScalingPolicyRequestBodyScalingPolicyType
	RECURRENCE CreateScalingPolicyRequestBodyScalingPolicyType
}

func GetCreateScalingPolicyRequestBodyScalingPolicyTypeEnum 

func GetCreateScalingPolicyRequestBodyScalingPolicyTypeEnum() CreateScalingPolicyRequestBodyScalingPolicyTypeEnum

type CreateScalingPolicyResponse 

type CreateScalingPolicyResponse struct {
	// 伸缩策略ID。
	ScalingPolicyId *string `json:"scaling_policy_id,omitempty"`
}

Response Object

func (CreateScalingPolicyResponse) String 

func (o CreateScalingPolicyResponse) String() string

type CreateScalingTagsRequest 

type CreateScalingTagsRequest struct {
	ResourceType CreateScalingTagsRequestResourceType `json:"resource_type"`
	ResourceId   string                               `json:"resource_id"`
	Body         *CreateScalingTagsRequestBody        `json:"body,omitempty"`
}

Request Object

func (CreateScalingTagsRequest) String 

func (o CreateScalingTagsRequest) String() string

type CreateScalingTagsRequestBody 

type CreateScalingTagsRequestBody struct {
	// 标签列表。
	Tags *[]TagsSingleValue `json:"tags,omitempty"`
	// 操作标识（区分大小写）：create：创建。若已经存在相同的key值则会覆盖对应的value值。
	Action *CreateScalingTagsRequestBodyAction `json:"action,omitempty"`
}

标签列表

func (CreateScalingTagsRequestBody) String 

func (o CreateScalingTagsRequestBody) String() string

type CreateScalingTagsRequestBodyAction 

type CreateScalingTagsRequestBodyAction struct {
	// contains filtered or unexported fields
}

func (CreateScalingTagsRequestBodyAction) MarshalJSON 

func (c CreateScalingTagsRequestBodyAction) MarshalJSON() ([]byte, error)

func (*CreateScalingTagsRequestBodyAction) UnmarshalJSON 

func (c *CreateScalingTagsRequestBodyAction) UnmarshalJSON(b []byte) error

type CreateScalingTagsRequestBodyActionEnum 

type CreateScalingTagsRequestBodyActionEnum struct {
	CREATE CreateScalingTagsRequestBodyAction
}

func GetCreateScalingTagsRequestBodyActionEnum 

func GetCreateScalingTagsRequestBodyActionEnum() CreateScalingTagsRequestBodyActionEnum

type CreateScalingTagsRequestResourceType 

type CreateScalingTagsRequestResourceType struct {
	// contains filtered or unexported fields
}

func (CreateScalingTagsRequestResourceType) MarshalJSON 

func (c CreateScalingTagsRequestResourceType) MarshalJSON() ([]byte, error)

func (*CreateScalingTagsRequestResourceType) UnmarshalJSON 

func (c *CreateScalingTagsRequestResourceType) UnmarshalJSON(b []byte) error

type CreateScalingTagsRequestResourceTypeEnum 

type CreateScalingTagsRequestResourceTypeEnum struct {
	SCALING_GROUP_TAG CreateScalingTagsRequestResourceType
}

func GetCreateScalingTagsRequestResourceTypeEnum 

func GetCreateScalingTagsRequestResourceTypeEnum() CreateScalingTagsRequestResourceTypeEnum

type CreateScalingTagsResponse 

type CreateScalingTagsResponse struct {
}

Response Object

func (CreateScalingTagsResponse) String 

func (o CreateScalingTagsResponse) String() string

type DeleteLifecycleHookRequest 

type DeleteLifecycleHookRequest struct {
	ScalingGroupId    string `json:"scaling_group_id"`
	LifecycleHookName string `json:"lifecycle_hook_name"`
}

Request Object

func (DeleteLifecycleHookRequest) String 

func (o DeleteLifecycleHookRequest) String() string

type DeleteLifecycleHookResponse 

type DeleteLifecycleHookResponse struct {
}

Response Object

func (DeleteLifecycleHookResponse) String 

func (o DeleteLifecycleHookResponse) String() string

type DeleteScalingConfigRequest 

type DeleteScalingConfigRequest struct {
	ScalingConfigurationId string `json:"scaling_configuration_id"`
}

Request Object

func (DeleteScalingConfigRequest) String 

func (o DeleteScalingConfigRequest) String() string

type DeleteScalingConfigResponse 

type DeleteScalingConfigResponse struct {
}

Response Object

func (DeleteScalingConfigResponse) String 

func (o DeleteScalingConfigResponse) String() string

type DeleteScalingGroupRequest 

type DeleteScalingGroupRequest struct {
	ScalingGroupId string                                `json:"scaling_group_id"`
	ForceDelete    *DeleteScalingGroupRequestForceDelete `json:"force_delete,omitempty"`
}

Request Object

func (DeleteScalingGroupRequest) String 

func (o DeleteScalingGroupRequest) String() string

type DeleteScalingGroupRequestForceDelete 

type DeleteScalingGroupRequestForceDelete struct {
	// contains filtered or unexported fields
}

func (DeleteScalingGroupRequestForceDelete) MarshalJSON 

func (c DeleteScalingGroupRequestForceDelete) MarshalJSON() ([]byte, error)

func (*DeleteScalingGroupRequestForceDelete) UnmarshalJSON 

func (c *DeleteScalingGroupRequestForceDelete) UnmarshalJSON(b []byte) error

type DeleteScalingGroupRequestForceDeleteEnum 

type DeleteScalingGroupRequestForceDeleteEnum struct {
	TRUE  DeleteScalingGroupRequestForceDelete
	FALSE DeleteScalingGroupRequestForceDelete
}

func GetDeleteScalingGroupRequestForceDeleteEnum 

func GetDeleteScalingGroupRequestForceDeleteEnum() DeleteScalingGroupRequestForceDeleteEnum

type DeleteScalingGroupResponse 

type DeleteScalingGroupResponse struct {
}

Response Object

func (DeleteScalingGroupResponse) String 

func (o DeleteScalingGroupResponse) String() string

type DeleteScalingInstanceRequest 

type DeleteScalingInstanceRequest struct {
	InstanceId     string                                      `json:"instance_id"`
	InstanceDelete *DeleteScalingInstanceRequestInstanceDelete `json:"instance_delete,omitempty"`
}

Request Object

func (DeleteScalingInstanceRequest) String 

func (o DeleteScalingInstanceRequest) String() string

type DeleteScalingInstanceRequestInstanceDelete 

type DeleteScalingInstanceRequestInstanceDelete struct {
	// contains filtered or unexported fields
}

func (DeleteScalingInstanceRequestInstanceDelete) MarshalJSON 

func (c DeleteScalingInstanceRequestInstanceDelete) MarshalJSON() ([]byte, error)

func (*DeleteScalingInstanceRequestInstanceDelete) UnmarshalJSON 

func (c *DeleteScalingInstanceRequestInstanceDelete) UnmarshalJSON(b []byte) error

type DeleteScalingInstanceRequestInstanceDeleteEnum 

type DeleteScalingInstanceRequestInstanceDeleteEnum struct {
	YES DeleteScalingInstanceRequestInstanceDelete
	NO  DeleteScalingInstanceRequestInstanceDelete
}

func GetDeleteScalingInstanceRequestInstanceDeleteEnum 

func GetDeleteScalingInstanceRequestInstanceDeleteEnum() DeleteScalingInstanceRequestInstanceDeleteEnum

type DeleteScalingInstanceResponse 

type DeleteScalingInstanceResponse struct {
}

Response Object

func (DeleteScalingInstanceResponse) String 

func (o DeleteScalingInstanceResponse) String() string

type DeleteScalingNotificationRequest 

type DeleteScalingNotificationRequest struct {
	ScalingGroupId string `json:"scaling_group_id"`
	TopicUrn       string `json:"topic_urn"`
}

Request Object

func (DeleteScalingNotificationRequest) String 

func (o DeleteScalingNotificationRequest) String() string

type DeleteScalingNotificationResponse 

type DeleteScalingNotificationResponse struct {
}

Response Object

func (DeleteScalingNotificationResponse) String 

func (o DeleteScalingNotificationResponse) String() string

type DeleteScalingPolicyRequest 

type DeleteScalingPolicyRequest struct {
	ScalingPolicyId string `json:"scaling_policy_id"`
}

Request Object

func (DeleteScalingPolicyRequest) String 

func (o DeleteScalingPolicyRequest) String() string

type DeleteScalingPolicyResponse 

type DeleteScalingPolicyResponse struct {
}

Response Object

func (DeleteScalingPolicyResponse) String 

func (o DeleteScalingPolicyResponse) String() string

type DeleteScalingTagsRequest 

type DeleteScalingTagsRequest struct {
	ResourceType DeleteScalingTagsRequestResourceType `json:"resource_type"`
	ResourceId   string                               `json:"resource_id"`
	Body         *DeleteScalingTagsRequestBody        `json:"body,omitempty"`
}

Request Object

func (DeleteScalingTagsRequest) String 

func (o DeleteScalingTagsRequest) String() string

type DeleteScalingTagsRequestBody 

type DeleteScalingTagsRequestBody struct {
	// 标签列表。action为delete时，tags结构体不能缺失，key不能为空，或者空字符串。
	Tags *[]TagsSingleValue `json:"tags,omitempty"`
	// 操作标识（区分大小写）：delete：删除。
	Action *DeleteScalingTagsRequestBodyAction `json:"action,omitempty"`
}

标签列表

func (DeleteScalingTagsRequestBody) String 

func (o DeleteScalingTagsRequestBody) String() string

type DeleteScalingTagsRequestBodyAction 

type DeleteScalingTagsRequestBodyAction struct {
	// contains filtered or unexported fields
}

func (DeleteScalingTagsRequestBodyAction) MarshalJSON 

func (c DeleteScalingTagsRequestBodyAction) MarshalJSON() ([]byte, error)

func (*DeleteScalingTagsRequestBodyAction) UnmarshalJSON 

func (c *DeleteScalingTagsRequestBodyAction) UnmarshalJSON(b []byte) error

type DeleteScalingTagsRequestBodyActionEnum 

type DeleteScalingTagsRequestBodyActionEnum struct {
	DELETE DeleteScalingTagsRequestBodyAction
}

func GetDeleteScalingTagsRequestBodyActionEnum 

func GetDeleteScalingTagsRequestBodyActionEnum() DeleteScalingTagsRequestBodyActionEnum

type DeleteScalingTagsRequestResourceType 

type DeleteScalingTagsRequestResourceType struct {
	// contains filtered or unexported fields
}

func (DeleteScalingTagsRequestResourceType) MarshalJSON 

func (c DeleteScalingTagsRequestResourceType) MarshalJSON() ([]byte, error)

func (*DeleteScalingTagsRequestResourceType) UnmarshalJSON 

func (c *DeleteScalingTagsRequestResourceType) UnmarshalJSON(b []byte) error

type DeleteScalingTagsRequestResourceTypeEnum 

type DeleteScalingTagsRequestResourceTypeEnum struct {
	SCALING_GROUP_TAG DeleteScalingTagsRequestResourceType
}

func GetDeleteScalingTagsRequestResourceTypeEnum 

func GetDeleteScalingTagsRequestResourceTypeEnum() DeleteScalingTagsRequestResourceTypeEnum

type DeleteScalingTagsResponse 

type DeleteScalingTagsResponse struct {
}

Response Object

func (DeleteScalingTagsResponse) String 

func (o DeleteScalingTagsResponse) String() string

type Disk 

type Disk struct {
	// 磁盘大小，容量单位为GB。系统盘输入大小范围为40~32768，且不小于镜像中系统盘的最小(min_disk属性)值。数据盘输入大小范围为10~32768。
	Size int32 `json:"size"`
	// 云服务器数据盘对应的磁盘类型，需要与系统所提供的磁盘类型相匹配。磁盘类型枚举值：SATA：普通IO磁盘类型。SAS：高IO磁盘类型。SSD：超高IO磁盘类型。co-pl：高IO (性能优化Ⅰ型)磁盘类型。uh-l1：超高 IO (时延优化)磁盘类型。说明：对于HANA云服务器和HL1型云服务器，需使用co-p1和uh-l1两种磁盘类型。对于其他类型的云服务器，不能使用co-p1和uh-l1两种磁盘类型。
	VolumeType DiskVolumeType `json:"volume_type"`
	// 系统盘还是数据盘，DATA表示为数据盘，SYS表示为系统盘。
	DiskType DiskDiskType `json:"disk_type"`
	// 云服务器的磁盘可指定创建在用户的专属存储中，需要指定专属存储ID。说明：同一个伸缩配置中的磁盘需统一指定或统一不指定专属存储，不支持混用；当指定专属存储时，所有专属存储需要属于同一个可用分区，且每个磁盘选择的专属存储支持的磁盘类型都需要和参数volume_type保持一致。
	DedicateStorageId *string `json:"dedicate_storage_id,omitempty"`
	// 云服务器的数据盘可指定从数据盘镜像导出，需要指定数据盘镜像ID。
	DataDiskImageId *string `json:"data_disk_image_id,omitempty"`
	// 当选择使用整机镜像时，云服务器的系统盘及数据盘将通过整机备份恢复，需要指定磁盘备份的快照ID。说明：磁盘备份的快照ID可通过镜像的整机备份ID在CSBS查询备份详情获得；一个伸缩配置中的每一个disk需要通过snapshot_id和整机备份中的磁盘备份一一对应。
	SnapshotId *string `json:"snapshot_id,omitempty"`
}

磁盘组信息，系统盘必选，数据盘可选。

func (Disk) String 

func (o Disk) String() string

type DiskDiskType 

type DiskDiskType struct {
	// contains filtered or unexported fields
}

func (DiskDiskType) MarshalJSON 

func (c DiskDiskType) MarshalJSON() ([]byte, error)

func (*DiskDiskType) UnmarshalJSON 

func (c *DiskDiskType) UnmarshalJSON(b []byte) error

type DiskDiskTypeEnum 

type DiskDiskTypeEnum struct {
	SYS  DiskDiskType
	DATA DiskDiskType
}

func GetDiskDiskTypeEnum 

func GetDiskDiskTypeEnum() DiskDiskTypeEnum

type DiskVolumeType 

type DiskVolumeType struct {
	// contains filtered or unexported fields
}

func (DiskVolumeType) MarshalJSON 

func (c DiskVolumeType) MarshalJSON() ([]byte, error)

func (*DiskVolumeType) UnmarshalJSON 

func (c *DiskVolumeType) UnmarshalJSON(b []byte) error

type DiskVolumeTypeEnum 

type DiskVolumeTypeEnum struct {
	SATA  DiskVolumeType
	SAS   DiskVolumeType
	SSD   DiskVolumeType
	CO_PL DiskVolumeType
	UH_11 DiskVolumeType
}

func GetDiskVolumeTypeEnum 

func GetDiskVolumeTypeEnum() DiskVolumeTypeEnum

type Eip 

type Eip struct {
	// 弹性IP地址类型。类型枚举值：5_bgp：全动态BGP;5_sbgp：静态BGP;5_telcom：中国电信;5_union：中国联通;详情请参见《虚拟私有云接口参考》“申请弹性公网IP”章节的“publicip”字段说明。
	IpType    EipIpType  `json:"ip_type"`
	Bandwidth *Bandwidth `json:"bandwidth"`
}

配置云服务器的弹性IP信息

func (Eip) String 

func (o Eip) String() string

type EipIpType 

type EipIpType struct {
	// contains filtered or unexported fields
}

func (EipIpType) MarshalJSON 

func (c EipIpType) MarshalJSON() ([]byte, error)

func (*EipIpType) UnmarshalJSON 

func (c *EipIpType) UnmarshalJSON(b []byte) error

type EipIpTypeEnum 

type EipIpTypeEnum struct {
	E_5_BGP    EipIpType
	E_5_SBGP   EipIpType
	E_5_TELCOM EipIpType
	E_5_UNION  EipIpType
}

func GetEipIpTypeEnum 

func GetEipIpTypeEnum() EipIpTypeEnum

type EnableOrDisableScalingGroupRequest 

type EnableOrDisableScalingGroupRequest struct {
	ScalingGroupId string                                  `json:"scaling_group_id"`
	Body           *EnableOrDisableScalingGroupRequestBody `json:"body,omitempty"`
}

Request Object

func (EnableOrDisableScalingGroupRequest) String 

func (o EnableOrDisableScalingGroupRequest) String() string

type EnableOrDisableScalingGroupRequestBody 

type EnableOrDisableScalingGroupRequestBody struct {
	// 启用或停止伸缩组操作的标识。启用：resume 停止：pause
	Action *EnableOrDisableScalingGroupRequestBodyAction `json:"action,omitempty"`
}

启停伸缩组请求

func (EnableOrDisableScalingGroupRequestBody) String 

func (o EnableOrDisableScalingGroupRequestBody) String() string

type EnableOrDisableScalingGroupRequestBodyAction 

type EnableOrDisableScalingGroupRequestBodyAction struct {
	// contains filtered or unexported fields
}

func (EnableOrDisableScalingGroupRequestBodyAction) MarshalJSON 

func (c EnableOrDisableScalingGroupRequestBodyAction) MarshalJSON() ([]byte, error)

func (*EnableOrDisableScalingGroupRequestBodyAction) UnmarshalJSON 

func (c *EnableOrDisableScalingGroupRequestBodyAction) UnmarshalJSON(b []byte) error

type EnableOrDisableScalingGroupRequestBodyActionEnum 

type EnableOrDisableScalingGroupRequestBodyActionEnum struct {
	RESUME EnableOrDisableScalingGroupRequestBodyAction
	PAUSE  EnableOrDisableScalingGroupRequestBodyAction
}

func GetEnableOrDisableScalingGroupRequestBodyActionEnum 

func GetEnableOrDisableScalingGroupRequestBodyActionEnum() EnableOrDisableScalingGroupRequestBodyActionEnum

type EnableOrDisableScalingGroupResponse 

type EnableOrDisableScalingGroupResponse struct {
}

Response Object

func (EnableOrDisableScalingGroupResponse) String 

func (o EnableOrDisableScalingGroupResponse) String() string

type ExecuteScalingPolicyRequest 

type ExecuteScalingPolicyRequest struct {
	ScalingPolicyId string                           `json:"scaling_policy_id"`
	Body            *ExecuteScalingPolicyRequestBody `json:"body,omitempty"`
}

Request Object

func (ExecuteScalingPolicyRequest) String 

func (o ExecuteScalingPolicyRequest) String() string

type ExecuteScalingPolicyRequestBody 

type ExecuteScalingPolicyRequestBody struct {
	// 执行或启用或停止伸缩策略操作的标识。执行：execute。启用：resume。停止：pause。
	Action *ExecuteScalingPolicyRequestBodyAction `json:"action,omitempty"`
}

执行或启用或停止伸缩策略

func (ExecuteScalingPolicyRequestBody) String 

func (o ExecuteScalingPolicyRequestBody) String() string

type ExecuteScalingPolicyRequestBodyAction 

type ExecuteScalingPolicyRequestBodyAction struct {
	// contains filtered or unexported fields
}

func (ExecuteScalingPolicyRequestBodyAction) MarshalJSON 

func (c ExecuteScalingPolicyRequestBodyAction) MarshalJSON() ([]byte, error)

func (*ExecuteScalingPolicyRequestBodyAction) UnmarshalJSON 

func (c *ExecuteScalingPolicyRequestBodyAction) UnmarshalJSON(b []byte) error

type ExecuteScalingPolicyRequestBodyActionEnum 

type ExecuteScalingPolicyRequestBodyActionEnum struct {
	EXECUTE ExecuteScalingPolicyRequestBodyAction
	RESUME  ExecuteScalingPolicyRequestBodyAction
	PAUSE   ExecuteScalingPolicyRequestBodyAction
}

func GetExecuteScalingPolicyRequestBodyActionEnum 

func GetExecuteScalingPolicyRequestBodyActionEnum() ExecuteScalingPolicyRequestBodyActionEnum

type ExecuteScalingPolicyResponse 

type ExecuteScalingPolicyResponse struct {
}

Response Object

func (ExecuteScalingPolicyResponse) String 

func (o ExecuteScalingPolicyResponse) String() string

type InstanceConfig 

type InstanceConfig struct {
	// 云服务器ID，当使用已存在的云服务器的规格为模板创建弹性伸缩配置时传入该字段，此时flavorRef、imageRef、disk、security_groups、tenancy和dedicated_host_id字段不生效。当不传入instance_id字段时flavorRef、imageRef、disk字段为必选。
	InstanceId *string `json:"instance_id,omitempty"`
	// 云服务器的规格ID。最多支持选择10个规格，多个规格ID以逗号分隔。云服务器的ID通过查询弹性云服务器规格详情和扩展信息列表接口获取，详情请参考查询云服务器规格详情和扩展信息列表。
	FlavorRef *string `json:"flavorRef,omitempty"`
	// 镜像ID，同image_id，通过查询镜像服务镜像列表接口获取，详见《镜像服务API参考》的“查询镜像列表”。
	ImageRef *string `json:"imageRef,omitempty"`
	// 磁盘组信息，系统盘必选，数据盘可选。
	Disk *[]Disk `json:"disk,omitempty"`
	// 登录云服务器的SSH密钥名称，与adminPass互斥，且必选一个。Windoes弹性云服务器不支持使用密钥登陆方式。
	KeyName *string `json:"key_name,omitempty"`
	// 注入文件信息。仅支持注入文本文件，最大支持注入5个文件，每个文件最大1KB。
	Personality *[]Personality `json:"personality,omitempty"`
	PublicIp    *PublicIp      `json:"public_ip,omitempty"`
	// cloud-init用户数据。支持注入文本、文本文件或gzip文件。文件内容需要进行base64格式编码，注入内容（编码之前的内容）最大为32KB。说明：当key_name没有指定时，user_data注入的数据默认为云服务器root账号的登录密码。创建密码方式鉴权的Linux弹性云服务器时为必填项，为root用户注入自定义初始化密码。
	UserData *string   `json:"user_data,omitempty"`
	Metadata *MetaData `json:"metadata,omitempty"`
	// 安全组信息。使用vpc_id通过查询VPC服务安全组列表接口获取，详见《虚拟私有云API参考》的“查询安全组列表”。当伸缩配置和伸缩组同时指定安全组时，将以伸缩配置中的安全组为准；当伸缩配置和伸缩组都没有指定安全组时，将使用默认安全组。为了使用灵活性更高，推荐在伸缩配置中指定安全组。
	SecurityGroups *[]SecurityGroups `json:"security_groups,omitempty"`
	// 云服务器组ID。
	ServerGroupId *string `json:"server_group_id,omitempty"`
	// 在专属主机上创建弹性云服务器。参数取值为dedicated。
	Tenancy *InstanceConfigTenancy `json:"tenancy,omitempty"`
	// 专属主机的ID。 说明：该字段仅在tenancy为dedicated时生效；如果指定该字段，云服务器将被创建到指定的专属主机上；如果不指定该字段，此时系统会将云服务器创建在符合规格的专属主机中剩余内存最大的那一台上，以使各专属主机尽量均衡负载。
	DedicatedHostId *string `json:"dedicated_host_id,omitempty"`
	// 使用伸缩配置创建云主机的时候，多规格使用的优先级策略。PICK_FIRST（默认）：选择优先，虚拟机扩容时规格的选择按照flavorRef列表的顺序进行优先级排序。COST_FIRST：成本优化，虚拟机扩容时规格的选择按照价格最优原则进行优先级排序。
	MultiFlavorPriorityPolicy *InstanceConfigMultiFlavorPriorityPolicy `json:"multi_flavor_priority_policy,omitempty"`
	// 云服务器的计费模式，可以选择竞价计费或按需计费，取值如下：按需计费：不指定该字段。竞价计费：spot
	MarketType *InstanceConfigMarketType `json:"market_type,omitempty"`
}

实例配置信息

func (InstanceConfig) String 

func (o InstanceConfig) String() string

type InstanceConfigMarketType 

type InstanceConfigMarketType struct {
	// contains filtered or unexported fields
}

func (InstanceConfigMarketType) MarshalJSON 

func (c InstanceConfigMarketType) MarshalJSON() ([]byte, error)

func (*InstanceConfigMarketType) UnmarshalJSON 

func (c *InstanceConfigMarketType) UnmarshalJSON(b []byte) error

type InstanceConfigMarketTypeEnum 

type InstanceConfigMarketTypeEnum struct {
	SPOT InstanceConfigMarketType
}

func GetInstanceConfigMarketTypeEnum 

func GetInstanceConfigMarketTypeEnum() InstanceConfigMarketTypeEnum

type InstanceConfigMultiFlavorPriorityPolicy 

type InstanceConfigMultiFlavorPriorityPolicy struct {
	// contains filtered or unexported fields
}

func (InstanceConfigMultiFlavorPriorityPolicy) MarshalJSON 

func (c InstanceConfigMultiFlavorPriorityPolicy) MarshalJSON() ([]byte, error)

func (*InstanceConfigMultiFlavorPriorityPolicy) UnmarshalJSON 

func (c *InstanceConfigMultiFlavorPriorityPolicy) UnmarshalJSON(b []byte) error

type InstanceConfigMultiFlavorPriorityPolicyEnum 

type InstanceConfigMultiFlavorPriorityPolicyEnum struct {
	PICK_FIRST InstanceConfigMultiFlavorPriorityPolicy
	COST_FIRST InstanceConfigMultiFlavorPriorityPolicy
}

func GetInstanceConfigMultiFlavorPriorityPolicyEnum 

func GetInstanceConfigMultiFlavorPriorityPolicyEnum() InstanceConfigMultiFlavorPriorityPolicyEnum

type InstanceConfigResult 

type InstanceConfigResult struct {
	// 云服务器的规格ID。
	FlavorRef *string `json:"flavorRef,omitempty"`
	// 镜像ID，同image_id。
	ImageRef *string `json:"imageRef,omitempty"`
	// 磁盘组信息。
	Disk *[]Disk `json:"disk,omitempty"`
	// 登录云服务器的SSH密钥名称。
	KeyName *string `json:"key_name,omitempty"`
	// 该参数为预留字段。
	InstanceName *string `json:"instance_name,omitempty"`
	// 该参数为预留字段。
	InstanceId *string `json:"instance_id,omitempty"`
	// 登录云服务器的密码，非明文回显。
	AdminPass   *string      `json:"adminPass,omitempty"`
	Personality *Personality `json:"personality,omitempty"`
	PublicIp    *PublicIp    `json:"public_ip,omitempty"`
	// cloud-init用户数据，base64格式编码。
	UserData *string   `json:"user_data,omitempty"`
	Metadata *MetaData `json:"metadata,omitempty"`
	// 安全组信息。
	SecurityGroups *[]SecurityGroups `json:"security_groups,omitempty"`
	// 云服务器组ID。
	ServerGroupId *string `json:"server_group_id,omitempty"`
	// 在专属主机上创建弹性云服务器。
	Tenancy *string `json:"tenancy,omitempty"`
	// 专属主机的ID。
	DedicatedHostId *string `json:"dedicated_host_id,omitempty"`
}

实例配置信息

func (InstanceConfigResult) String 

func (o InstanceConfigResult) String() string

type InstanceConfigTenancy 

type InstanceConfigTenancy struct {
	// contains filtered or unexported fields
}

func (InstanceConfigTenancy) MarshalJSON 

func (c InstanceConfigTenancy) MarshalJSON() ([]byte, error)

func (*InstanceConfigTenancy) UnmarshalJSON 

func (c *InstanceConfigTenancy) UnmarshalJSON(b []byte) error

type InstanceConfigTenancyEnum 

type InstanceConfigTenancyEnum struct {
	DEDICATED InstanceConfigTenancy
}

func GetInstanceConfigTenancyEnum 

func GetInstanceConfigTenancyEnum() InstanceConfigTenancyEnum

type InstanceHangingInfos 

type InstanceHangingInfos struct {
	// 生命周期挂钩名称。
	LifecycleHookName *string `json:"lifecycle_hook_name,omitempty"`
	// 生命周期操作令牌，用于指定生命周期回调对象。
	LifecycleActionKey *string `json:"lifecycle_action_key,omitempty"`
	// 伸缩实例ID。
	InstanceId *string `json:"instance_id,omitempty"`
	// 伸缩组ID。
	ScalingGroupId *string `json:"scaling_group_id,omitempty"`
	// 伸缩实例挂钩的挂起状态。HANGING：挂起。CONTINUE：继续。ABANDON：终止。
	LifecycleHookStatus *InstanceHangingInfosLifecycleHookStatus `json:"lifecycle_hook_status,omitempty"`
	// 超时时间，遵循UTC时间，格式为：YYYY-MM-DDThh:mm:ssZZ。
	Timeout *sdktime.SdkTime `json:"timeout,omitempty"`
	// 生命周期挂钩默认回调操作。
	DefaultResult *string `json:"default_result,omitempty"`
}

挂钩实例信息

func (InstanceHangingInfos) String 

func (o InstanceHangingInfos) String() string

type InstanceHangingInfosLifecycleHookStatus 

type InstanceHangingInfosLifecycleHookStatus struct {
	// contains filtered or unexported fields
}

func (InstanceHangingInfosLifecycleHookStatus) MarshalJSON 

func (c InstanceHangingInfosLifecycleHookStatus) MarshalJSON() ([]byte, error)

func (*InstanceHangingInfosLifecycleHookStatus) UnmarshalJSON 

func (c *InstanceHangingInfosLifecycleHookStatus) UnmarshalJSON(b []byte) error

type InstanceHangingInfosLifecycleHookStatusEnum 

type InstanceHangingInfosLifecycleHookStatusEnum struct {
	HANGING  InstanceHangingInfosLifecycleHookStatus
	CONTINUE InstanceHangingInfosLifecycleHookStatus
	ABANDON  InstanceHangingInfosLifecycleHookStatus
}

func GetInstanceHangingInfosLifecycleHookStatusEnum 

func GetInstanceHangingInfosLifecycleHookStatusEnum() InstanceHangingInfosLifecycleHookStatusEnum

type Ipv6Bandwidth 

type Ipv6Bandwidth struct {
	// IPv6共享带宽的ID。
	Id string `json:"id"`
}

IPv6信息

func (Ipv6Bandwidth) String 

func (o Ipv6Bandwidth) String() string

type JobRecords 

type JobRecords struct {
	// 任务名称
	JobName *string `json:"job_name,omitempty"`
	// 记录类型。API：接口调用类型。MEG：消息类型。
	RecordType *JobRecordsRecordType `json:"record_type,omitempty"`
	// 记录时间。
	RecordTime *string `json:"record_time,omitempty"`
	// 请求体，仅当record_type为API时有效
	Request *string `json:"request,omitempty"`
	// 返回体，仅当record_type为API时有效
	Response *string `json:"response,omitempty"`
	// 返回码，仅当record_type为API时有效
	Code *int32 `json:"code,omitempty"`
	// 消息，仅当record_type为MEG时有效
	Message *string `json:"message,omitempty"`
	// job执行状态：SUCCESS：成功。FAIL：失败。
	JobStatus *JobRecordsJobStatus `json:"job_status,omitempty"`
}

策略执行动作包含的具体任务

func (JobRecords) String 

func (o JobRecords) String() string

type JobRecordsJobStatus 

type JobRecordsJobStatus struct {
	// contains filtered or unexported fields
}

func (JobRecordsJobStatus) MarshalJSON 

func (c JobRecordsJobStatus) MarshalJSON() ([]byte, error)

func (*JobRecordsJobStatus) UnmarshalJSON 

func (c *JobRecordsJobStatus) UnmarshalJSON(b []byte) error

type JobRecordsJobStatusEnum 

type JobRecordsJobStatusEnum struct {
	SUCCESS JobRecordsJobStatus
	FAIL    JobRecordsJobStatus
}

func GetJobRecordsJobStatusEnum 

func GetJobRecordsJobStatusEnum() JobRecordsJobStatusEnum

type JobRecordsRecordType 

type JobRecordsRecordType struct {
	// contains filtered or unexported fields
}

func (JobRecordsRecordType) MarshalJSON 

func (c JobRecordsRecordType) MarshalJSON() ([]byte, error)

func (*JobRecordsRecordType) UnmarshalJSON 

func (c *JobRecordsRecordType) UnmarshalJSON(b []byte) error

type JobRecordsRecordTypeEnum 

type JobRecordsRecordTypeEnum struct {
	API JobRecordsRecordType
	MEG JobRecordsRecordType
}

func GetJobRecordsRecordTypeEnum 

func GetJobRecordsRecordTypeEnum() JobRecordsRecordTypeEnum

type LbaasListeners 

type LbaasListeners struct {
	// 后端云服务器组ID
	PoolId string `json:"pool_id"`
	// 后端协议号，指后端云服务器监听的端口，取值范围[1,65535]
	ProtocolPort int32 `json:"protocol_port"`
	// 权重，指后端云服务器经分发得到的请求数量比例，取值范围[0,1]，默认为1。
	Weight *int32 `json:"weight,omitempty"`
}

增强型负载均衡器

func (LbaasListeners) String 

func (o LbaasListeners) String() string

type LbaasListenersResult 

type LbaasListenersResult struct {
	// 监听器ID
	ListenersId *string `json:"listeners_id,omitempty"`
	// 后端云服务器组ID
	PoolId *string `json:"pool_id,omitempty"`
	// 后端协议号，指后端云服务器监听的端口，取值范围[1,65535]
	ProtocolPort *int32 `json:"protocol_port,omitempty"`
	// 权重，指后端云服务器经分发得到的请求数量比例，取值范围[0,1]，默认为1。
	Weight *int32 `json:"weight,omitempty"`
}

增强型负载均衡器信息

func (LbaasListenersResult) String 

func (o LbaasListenersResult) String() string

type LifecycleHookList 

type LifecycleHookList struct {
	// 生命周期挂钩名称。
	LifecycleHookName *string `json:"lifecycle_hook_name,omitempty"`
	// 生命周期挂钩类型。INSTANCE_TERMINATING；INSTANCE_LAUNCHING。
	LifecycleHookType *LifecycleHookListLifecycleHookType `json:"lifecycle_hook_type,omitempty"`
	// 生命周期挂钩默认回调操作。ABANDON;CONTINUE。
	DefaultResult *LifecycleHookListDefaultResult `json:"default_result,omitempty"`
	// 生命周期挂钩超时时间，单位秒。
	DefaultTimeout *int32 `json:"default_timeout,omitempty"`
	// SMN服务中Topic的唯一的资源标识。
	NotificationTopicUrn *string `json:"notification_topic_urn,omitempty"`
	// SMN服务中Topic的资源名称。
	NotificationTopicName *string `json:"notification_topic_name,omitempty"`
	// 自定义通知消息。
	NotificationMetadata *string `json:"notification_metadata,omitempty"`
	// 创建生命周期挂钩时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
}

生命周期挂钩

func (LifecycleHookList) String 

func (o LifecycleHookList) String() string

type LifecycleHookListDefaultResult 

type LifecycleHookListDefaultResult struct {
	// contains filtered or unexported fields
}

func (LifecycleHookListDefaultResult) MarshalJSON 

func (c LifecycleHookListDefaultResult) MarshalJSON() ([]byte, error)

func (*LifecycleHookListDefaultResult) UnmarshalJSON 

func (c *LifecycleHookListDefaultResult) UnmarshalJSON(b []byte) error

type LifecycleHookListDefaultResultEnum 

type LifecycleHookListDefaultResultEnum struct {
	ABANDON  LifecycleHookListDefaultResult
	CONTINUE LifecycleHookListDefaultResult
}

func GetLifecycleHookListDefaultResultEnum 

func GetLifecycleHookListDefaultResultEnum() LifecycleHookListDefaultResultEnum

type LifecycleHookListLifecycleHookType 

type LifecycleHookListLifecycleHookType struct {
	// contains filtered or unexported fields
}

func (LifecycleHookListLifecycleHookType) MarshalJSON 

func (c LifecycleHookListLifecycleHookType) MarshalJSON() ([]byte, error)

func (*LifecycleHookListLifecycleHookType) UnmarshalJSON 

func (c *LifecycleHookListLifecycleHookType) UnmarshalJSON(b []byte) error

type LifecycleHookListLifecycleHookTypeEnum 

type LifecycleHookListLifecycleHookTypeEnum struct {
	INSTANCE_TERMINATING LifecycleHookListLifecycleHookType
	INSTANCE_LAUNCHING   LifecycleHookListLifecycleHookType
}

func GetLifecycleHookListLifecycleHookTypeEnum 

func GetLifecycleHookListLifecycleHookTypeEnum() LifecycleHookListLifecycleHookTypeEnum

type ListHookInstancesRequest 

type ListHookInstancesRequest struct {
	ScalingGroupId string  `json:"scaling_group_id"`
	InstanceId     *string `json:"instance_id,omitempty"`
}

Request Object

func (ListHookInstancesRequest) String 

func (o ListHookInstancesRequest) String() string

type ListHookInstancesResponse 

type ListHookInstancesResponse struct {
	// 伸缩实例生命周期挂钩列表。
	InstanceHangingInfo *[]InstanceHangingInfos `json:"instance_hanging_info,omitempty"`
}

Response Object

func (ListHookInstancesResponse) String 

func (o ListHookInstancesResponse) String() string

type ListLifeCycleHooksRequest 

type ListLifeCycleHooksRequest struct {
	ScalingGroupId string `json:"scaling_group_id"`
}

Request Object

func (ListLifeCycleHooksRequest) String 

func (o ListLifeCycleHooksRequest) String() string

type ListLifeCycleHooksResponse 

type ListLifeCycleHooksResponse struct {
	// 生命周期挂钩列表。
	LifecycleHooks *[]LifecycleHookList `json:"lifecycle_hooks,omitempty"`
}

Response Object

func (ListLifeCycleHooksResponse) String 

func (o ListLifeCycleHooksResponse) String() string

type ListResourceInstancesRequest 

type ListResourceInstancesRequest struct {
	ResourceType ListResourceInstancesRequestResourceType `json:"resource_type"`
	Body         *ShowTagsRequestBody                     `json:"body,omitempty"`
}

Request Object

func (ListResourceInstancesRequest) String 

func (o ListResourceInstancesRequest) String() string

type ListResourceInstancesRequestResourceType 

type ListResourceInstancesRequestResourceType struct {
	// contains filtered or unexported fields
}

func (ListResourceInstancesRequestResourceType) MarshalJSON 

func (c ListResourceInstancesRequestResourceType) MarshalJSON() ([]byte, error)

func (*ListResourceInstancesRequestResourceType) UnmarshalJSON 

func (c *ListResourceInstancesRequestResourceType) UnmarshalJSON(b []byte) error

type ListResourceInstancesRequestResourceTypeEnum 

type ListResourceInstancesRequestResourceTypeEnum struct {
	SCALING_GROUP_TAG ListResourceInstancesRequestResourceType
}

func GetListResourceInstancesRequestResourceTypeEnum 

func GetListResourceInstancesRequestResourceTypeEnum() ListResourceInstancesRequestResourceTypeEnum

type ListResourceInstancesResponse 

type ListResourceInstancesResponse struct {
	// 标签资源实例。
	Resources *[]Resources `json:"resources,omitempty"`
	// 总记录数。
	TotalCount *int32 `json:"total_count,omitempty"`
	// 分页位置标识。
	Marker *int32 `json:"marker,omitempty"`
}

Response Object

func (ListResourceInstancesResponse) String 

func (o ListResourceInstancesResponse) String() string

type ListScalingActivityLogsRequest 

type ListScalingActivityLogsRequest struct {
	ScalingGroupId string           `json:"scaling_group_id"`
	StartTime      *sdktime.SdkTime `json:"start_time,omitempty"`
	EndTime        *sdktime.SdkTime `json:"end_time,omitempty"`
	StartNumber    *int32           `json:"start_number,omitempty"`
	Limit          *int32           `json:"limit,omitempty"`
}

Request Object

func (ListScalingActivityLogsRequest) String 

func (o ListScalingActivityLogsRequest) String() string

type ListScalingActivityLogsResponse 

type ListScalingActivityLogsResponse struct {
	// 总记录数。
	TotalNumber *int32 `json:"total_number,omitempty"`
	// 查询的其实行号。
	StartNumber *int32 `json:"start_number,omitempty"`
	// 查询记录数。
	Limit *int32 `json:"limit,omitempty"`
	// 伸缩活动日志列表。
	ScalingActivityLog *[]ScalingActivityLogList `json:"scaling_activity_log,omitempty"`
}

Response Object

func (ListScalingActivityLogsResponse) String 

func (o ListScalingActivityLogsResponse) String() string

type ListScalingConfigsRequest 

type ListScalingConfigsRequest struct {
	ScalingConfigurationName *string `json:"scaling_configuration_name,omitempty"`
	ImageId                  *string `json:"image_id,omitempty"`
	StartNumber              *int32  `json:"start_number,omitempty"`
	Limit                    *int32  `json:"limit,omitempty"`
}

Request Object

func (ListScalingConfigsRequest) String 

func (o ListScalingConfigsRequest) String() string

type ListScalingConfigsResponse 

type ListScalingConfigsResponse struct {
	// 总记录数。
	TotalNumber *int32 `json:"total_number,omitempty"`
	// 查询的起始行号。
	StartNumber *int32 `json:"start_number,omitempty"`
	// 查询记录数。
	Limit *int32 `json:"limit,omitempty"`
	// 伸缩配置列表
	ScalingConfigurations *[]ScalingConfiguration `json:"scaling_configurations,omitempty"`
}

Response Object

func (ListScalingConfigsResponse) String 

func (o ListScalingConfigsResponse) String() string

type ListScalingGroupsRequest 

type ListScalingGroupsRequest struct {
	ScalingGroupName       *string                                     `json:"scaling_group_name,omitempty"`
	ScalingConfigurationId *string                                     `json:"scaling_configuration_id,omitempty"`
	ScalingGroupStatus     *ListScalingGroupsRequestScalingGroupStatus `json:"scaling_group_status,omitempty"`
	StartNumber            *int32                                      `json:"start_number,omitempty"`
	Limit                  *int32                                      `json:"limit,omitempty"`
}

Request Object

func (ListScalingGroupsRequest) String 

func (o ListScalingGroupsRequest) String() string

type ListScalingGroupsRequestScalingGroupStatus 

type ListScalingGroupsRequestScalingGroupStatus struct {
	// contains filtered or unexported fields
}

func (ListScalingGroupsRequestScalingGroupStatus) MarshalJSON 

func (c ListScalingGroupsRequestScalingGroupStatus) MarshalJSON() ([]byte, error)

func (*ListScalingGroupsRequestScalingGroupStatus) UnmarshalJSON 

func (c *ListScalingGroupsRequestScalingGroupStatus) UnmarshalJSON(b []byte) error

type ListScalingGroupsRequestScalingGroupStatusEnum 

type ListScalingGroupsRequestScalingGroupStatusEnum struct {
	INSERVICE ListScalingGroupsRequestScalingGroupStatus
	PAUSED    ListScalingGroupsRequestScalingGroupStatus
	ERROR     ListScalingGroupsRequestScalingGroupStatus
	DELETING  ListScalingGroupsRequestScalingGroupStatus
}

func GetListScalingGroupsRequestScalingGroupStatusEnum 

func GetListScalingGroupsRequestScalingGroupStatusEnum() ListScalingGroupsRequestScalingGroupStatusEnum

type ListScalingGroupsResponse 

type ListScalingGroupsResponse struct {
	// 总记录数
	TotalNumber *int32 `json:"total_number,omitempty"`
	// 查询的开始记录号
	StartNumber *int32 `json:"start_number,omitempty"`
	// 查询记录数
	Limit *int32 `json:"limit,omitempty"`
	// 伸缩组列表
	ScalingGroups *[]ScalingGroups `json:"scaling_groups,omitempty"`
}

Response Object

func (ListScalingGroupsResponse) String 

func (o ListScalingGroupsResponse) String() string

type ListScalingInstancesRequest 

type ListScalingInstancesRequest struct {
	ScalingGroupId         string                                             `json:"scaling_group_id"`
	LifeCycleState         *ListScalingInstancesRequestLifeCycleState         `json:"life_cycle_state,omitempty"`
	HealthStatus           *ListScalingInstancesRequestHealthStatus           `json:"health_status,omitempty"`
	ProtectFromScalingDown *ListScalingInstancesRequestProtectFromScalingDown `json:"protect_from_scaling_down,omitempty"`
	StartNumber            *int32                                             `json:"start_number,omitempty"`
	Limit                  *int32                                             `json:"limit,omitempty"`
}

Request Object

func (ListScalingInstancesRequest) String 

func (o ListScalingInstancesRequest) String() string

type ListScalingInstancesRequestHealthStatus 

type ListScalingInstancesRequestHealthStatus struct {
	// contains filtered or unexported fields
}

func (ListScalingInstancesRequestHealthStatus) MarshalJSON 

func (c ListScalingInstancesRequestHealthStatus) MarshalJSON() ([]byte, error)

func (*ListScalingInstancesRequestHealthStatus) UnmarshalJSON 

func (c *ListScalingInstancesRequestHealthStatus) UnmarshalJSON(b []byte) error

type ListScalingInstancesRequestHealthStatusEnum 

type ListScalingInstancesRequestHealthStatusEnum struct {
	INITIALIZING ListScalingInstancesRequestHealthStatus
	NORMAL       ListScalingInstancesRequestHealthStatus
	ERROR        ListScalingInstancesRequestHealthStatus
}

func GetListScalingInstancesRequestHealthStatusEnum 

func GetListScalingInstancesRequestHealthStatusEnum() ListScalingInstancesRequestHealthStatusEnum

type ListScalingInstancesRequestLifeCycleState 

type ListScalingInstancesRequestLifeCycleState struct {
	// contains filtered or unexported fields
}

func (ListScalingInstancesRequestLifeCycleState) MarshalJSON 

func (c ListScalingInstancesRequestLifeCycleState) MarshalJSON() ([]byte, error)

func (*ListScalingInstancesRequestLifeCycleState) UnmarshalJSON 

func (c *ListScalingInstancesRequestLifeCycleState) UnmarshalJSON(b []byte) error

type ListScalingInstancesRequestLifeCycleStateEnum 

type ListScalingInstancesRequestLifeCycleStateEnum struct {
	INSERVICE        ListScalingInstancesRequestLifeCycleState
	PENDING          ListScalingInstancesRequestLifeCycleState
	REMOVING         ListScalingInstancesRequestLifeCycleState
	PENDING_WAIT     ListScalingInstancesRequestLifeCycleState
	REMOVING_WAIT    ListScalingInstancesRequestLifeCycleState
	STANDBY          ListScalingInstancesRequestLifeCycleState
	ENTERING_STANDBY ListScalingInstancesRequestLifeCycleState
}

func GetListScalingInstancesRequestLifeCycleStateEnum 

func GetListScalingInstancesRequestLifeCycleStateEnum() ListScalingInstancesRequestLifeCycleStateEnum

type ListScalingInstancesRequestProtectFromScalingDown 

type ListScalingInstancesRequestProtectFromScalingDown struct {
	// contains filtered or unexported fields
}

func (ListScalingInstancesRequestProtectFromScalingDown) MarshalJSON 

func (c ListScalingInstancesRequestProtectFromScalingDown) MarshalJSON() ([]byte, error)

func (*ListScalingInstancesRequestProtectFromScalingDown) UnmarshalJSON 

func (c *ListScalingInstancesRequestProtectFromScalingDown) UnmarshalJSON(b []byte) error

type ListScalingInstancesRequestProtectFromScalingDownEnum 

type ListScalingInstancesRequestProtectFromScalingDownEnum struct {
	TRUE  ListScalingInstancesRequestProtectFromScalingDown
	FALSE ListScalingInstancesRequestProtectFromScalingDown
}

func GetListScalingInstancesRequestProtectFromScalingDownEnum 

func GetListScalingInstancesRequestProtectFromScalingDownEnum() ListScalingInstancesRequestProtectFromScalingDownEnum

type ListScalingInstancesResponse 

type ListScalingInstancesResponse struct {
	// 总记录数。
	TotalNumber *int32 `json:"total_number,omitempty"`
	// 查询的起始行号。
	StartNumber *int32 `json:"start_number,omitempty"`
	// 伸缩组实例详情。
	Limit *int32 `json:"limit,omitempty"`
	// 伸缩组实例详情。
	ScalingGroupInstances *[]ScalingGroupInstance `json:"scaling_group_instances,omitempty"`
}

Response Object

func (ListScalingInstancesResponse) String 

func (o ListScalingInstancesResponse) String() string

type ListScalingNotificationsRequest 

type ListScalingNotificationsRequest struct {
	ScalingGroupId string `json:"scaling_group_id"`
}

Request Object

func (ListScalingNotificationsRequest) String 

func (o ListScalingNotificationsRequest) String() string

type ListScalingNotificationsResponse 

type ListScalingNotificationsResponse struct {
	// 伸缩组通知列表。
	Topics *[]Topics `json:"topics,omitempty"`
}

Response Object

func (ListScalingNotificationsResponse) String 

func (o ListScalingNotificationsResponse) String() string

type ListScalingPoliciesRequest 

type ListScalingPoliciesRequest struct {
	ScalingGroupId    string                                       `json:"scaling_group_id"`
	ScalingPolicyName *string                                      `json:"scaling_policy_name,omitempty"`
	ScalingPolicyType *ListScalingPoliciesRequestScalingPolicyType `json:"scaling_policy_type,omitempty"`
	ScalingPolicyId   *string                                      `json:"scaling_policy_id,omitempty"`
	StartNumber       *int32                                       `json:"start_number,omitempty"`
	Limit             *int32                                       `json:"limit,omitempty"`
}

Request Object

func (ListScalingPoliciesRequest) String 

func (o ListScalingPoliciesRequest) String() string

type ListScalingPoliciesRequestScalingPolicyType 

type ListScalingPoliciesRequestScalingPolicyType struct {
	// contains filtered or unexported fields
}

func (ListScalingPoliciesRequestScalingPolicyType) MarshalJSON 

func (c ListScalingPoliciesRequestScalingPolicyType) MarshalJSON() ([]byte, error)

func (*ListScalingPoliciesRequestScalingPolicyType) UnmarshalJSON 

func (c *ListScalingPoliciesRequestScalingPolicyType) UnmarshalJSON(b []byte) error

type ListScalingPoliciesRequestScalingPolicyTypeEnum 

type ListScalingPoliciesRequestScalingPolicyTypeEnum struct {
	ALARM      ListScalingPoliciesRequestScalingPolicyType
	SCHEDULED  ListScalingPoliciesRequestScalingPolicyType
	RECURRENCE ListScalingPoliciesRequestScalingPolicyType
}

func GetListScalingPoliciesRequestScalingPolicyTypeEnum 

func GetListScalingPoliciesRequestScalingPolicyTypeEnum() ListScalingPoliciesRequestScalingPolicyTypeEnum

type ListScalingPoliciesResponse 

type ListScalingPoliciesResponse struct {
	// 总记录数。
	TotalNumber *int32 `json:"total_number,omitempty"`
	// 查询的起始行号。
	StartNumber *int32 `json:"start_number,omitempty"`
	// 查询记录数。
	Limit *int32 `json:"limit,omitempty"`
	// 伸缩策略列表
	ScalingPolicies *[]ScalingPolicyDetail `json:"scaling_policies,omitempty"`
}

Response Object

func (ListScalingPoliciesResponse) String 

func (o ListScalingPoliciesResponse) String() string

type ListScalingPolicyExecuteLogsRequest 

type ListScalingPolicyExecuteLogsRequest struct {
	ScalingPolicyId     string                                                  `json:"scaling_policy_id"`
	LogId               *string                                                 `json:"log_id,omitempty"`
	ScalingResourceType *ListScalingPolicyExecuteLogsRequestScalingResourceType `json:"scaling_resource_type,omitempty"`
	ScalingResourceId   *string                                                 `json:"scaling_resource_id,omitempty"`
	ExecuteType         *ListScalingPolicyExecuteLogsRequestExecuteType         `json:"execute_type,omitempty"`
	StartTime           *sdktime.SdkTime                                        `json:"start_time,omitempty"`
	EndTime             *sdktime.SdkTime                                        `json:"end_time,omitempty"`
	StartNumber         *int32                                                  `json:"start_number,omitempty"`
	Limit               *int32                                                  `json:"limit,omitempty"`
}

Request Object

func (ListScalingPolicyExecuteLogsRequest) String 

func (o ListScalingPolicyExecuteLogsRequest) String() string

type ListScalingPolicyExecuteLogsRequestExecuteType 

type ListScalingPolicyExecuteLogsRequestExecuteType struct {
	// contains filtered or unexported fields
}

func (ListScalingPolicyExecuteLogsRequestExecuteType) MarshalJSON 

func (c ListScalingPolicyExecuteLogsRequestExecuteType) MarshalJSON() ([]byte, error)

func (*ListScalingPolicyExecuteLogsRequestExecuteType) UnmarshalJSON 

func (c *ListScalingPolicyExecuteLogsRequestExecuteType) UnmarshalJSON(b []byte) error

type ListScalingPolicyExecuteLogsRequestExecuteTypeEnum 

type ListScalingPolicyExecuteLogsRequestExecuteTypeEnum struct {
	SCHEDULED  ListScalingPolicyExecuteLogsRequestExecuteType
	RECURRENCE ListScalingPolicyExecuteLogsRequestExecuteType
	ALARM      ListScalingPolicyExecuteLogsRequestExecuteType
	MANUAL     ListScalingPolicyExecuteLogsRequestExecuteType
}

func GetListScalingPolicyExecuteLogsRequestExecuteTypeEnum 

func GetListScalingPolicyExecuteLogsRequestExecuteTypeEnum() ListScalingPolicyExecuteLogsRequestExecuteTypeEnum

type ListScalingPolicyExecuteLogsRequestScalingResourceType 

type ListScalingPolicyExecuteLogsRequestScalingResourceType struct {
	// contains filtered or unexported fields
}

func (ListScalingPolicyExecuteLogsRequestScalingResourceType) MarshalJSON 

func (c ListScalingPolicyExecuteLogsRequestScalingResourceType) MarshalJSON() ([]byte, error)

func (*ListScalingPolicyExecuteLogsRequestScalingResourceType) UnmarshalJSON 

func (c *ListScalingPolicyExecuteLogsRequestScalingResourceType) UnmarshalJSON(b []byte) error

type ListScalingPolicyExecuteLogsRequestScalingResourceTypeEnum 

type ListScalingPolicyExecuteLogsRequestScalingResourceTypeEnum struct {
	SCALING_GROUP ListScalingPolicyExecuteLogsRequestScalingResourceType
	BANDWIDTH     ListScalingPolicyExecuteLogsRequestScalingResourceType
}

func GetListScalingPolicyExecuteLogsRequestScalingResourceTypeEnum 

func GetListScalingPolicyExecuteLogsRequestScalingResourceTypeEnum() ListScalingPolicyExecuteLogsRequestScalingResourceTypeEnum

type ListScalingPolicyExecuteLogsResponse 

type ListScalingPolicyExecuteLogsResponse struct {
	// 总记录数。
	TotalNumber *int32 `json:"total_number,omitempty"`
	// 查询的起始行号。
	StartNumber *int32 `json:"start_number,omitempty"`
	// 查询记录数。
	Limit *int32 `json:"limit,omitempty"`
	// 伸缩策略执行日志列表。
	ScalingPolicyExecuteLog *[]ScalingPolicyExecuteLogList `json:"scaling_policy_execute_log,omitempty"`
}

Response Object

func (ListScalingPolicyExecuteLogsResponse) String 

func (o ListScalingPolicyExecuteLogsResponse) String() string

type ListScalingTagInfosByResourceIdRequest 

type ListScalingTagInfosByResourceIdRequest struct {
	ResourceType ListScalingTagInfosByResourceIdRequestResourceType `json:"resource_type"`
	ResourceId   string                                             `json:"resource_id"`
}

Request Object

func (ListScalingTagInfosByResourceIdRequest) String 

func (o ListScalingTagInfosByResourceIdRequest) String() string

type ListScalingTagInfosByResourceIdRequestResourceType 

type ListScalingTagInfosByResourceIdRequestResourceType struct {
	// contains filtered or unexported fields
}

func (ListScalingTagInfosByResourceIdRequestResourceType) MarshalJSON 

func (c ListScalingTagInfosByResourceIdRequestResourceType) MarshalJSON() ([]byte, error)

func (*ListScalingTagInfosByResourceIdRequestResourceType) UnmarshalJSON 

func (c *ListScalingTagInfosByResourceIdRequestResourceType) UnmarshalJSON(b []byte) error

type ListScalingTagInfosByResourceIdRequestResourceTypeEnum 

type ListScalingTagInfosByResourceIdRequestResourceTypeEnum struct {
	SCALING_GROUP_TAG ListScalingTagInfosByResourceIdRequestResourceType
}

func GetListScalingTagInfosByResourceIdRequestResourceTypeEnum 

func GetListScalingTagInfosByResourceIdRequestResourceTypeEnum() ListScalingTagInfosByResourceIdRequestResourceTypeEnum

type ListScalingTagInfosByResourceIdResponse 

type ListScalingTagInfosByResourceIdResponse struct {
	// 资源标签列表。
	Tags *[]TagsSingleValue `json:"tags,omitempty"`
	// 系统资源标签列表。
	SysTags *[]TagsSingleValue `json:"sys_tags,omitempty"`
}

Response Object

func (ListScalingTagInfosByResourceIdResponse) String 

func (o ListScalingTagInfosByResourceIdResponse) String() string

type ListScalingTagInfosByTenantIdRequest 

type ListScalingTagInfosByTenantIdRequest struct {
	ResourceType ListScalingTagInfosByTenantIdRequestResourceType `json:"resource_type"`
}

Request Object

func (ListScalingTagInfosByTenantIdRequest) String 

func (o ListScalingTagInfosByTenantIdRequest) String() string

type ListScalingTagInfosByTenantIdRequestResourceType 

type ListScalingTagInfosByTenantIdRequestResourceType struct {
	// contains filtered or unexported fields
}

func (ListScalingTagInfosByTenantIdRequestResourceType) MarshalJSON 

func (c ListScalingTagInfosByTenantIdRequestResourceType) MarshalJSON() ([]byte, error)

func (*ListScalingTagInfosByTenantIdRequestResourceType) UnmarshalJSON 

func (c *ListScalingTagInfosByTenantIdRequestResourceType) UnmarshalJSON(b []byte) error

type ListScalingTagInfosByTenantIdRequestResourceTypeEnum 

type ListScalingTagInfosByTenantIdRequestResourceTypeEnum struct {
	SCALING_GROUP_TAG ListScalingTagInfosByTenantIdRequestResourceType
}

func GetListScalingTagInfosByTenantIdRequestResourceTypeEnum 

func GetListScalingTagInfosByTenantIdRequestResourceTypeEnum() ListScalingTagInfosByTenantIdRequestResourceTypeEnum

type ListScalingTagInfosByTenantIdResponse 

type ListScalingTagInfosByTenantIdResponse struct {
	// 资源标签。
	Tags *[]TagsMultiValue `json:"tags,omitempty"`
}

Response Object

func (ListScalingTagInfosByTenantIdResponse) String 

func (o ListScalingTagInfosByTenantIdResponse) String() string

type Matches 

type Matches struct {
	// 键。暂限定为resource_name。
	Key *string `json:"key,omitempty"`
	// 值。为固定字典值。每个值最大长度255个unicode字符。若为空字符串、resource_id时为精确匹配。
	Value *string `json:"value,omitempty"`
}

func (Matches) String 

func (o Matches) String() string

type MetaData 

type MetaData struct {
	// 用户自定义数据总长度不大于512字节。用户自定义键不能是空串，不能包含符号.，以及不能以符号$开头。说明：Windows弹性云服务器Administrator用户的密码。示例：键（固定）：admin_pass值：cloud.1234创建密码方式鉴权的Windows弹性云服务器时为必选字段。
	CustomizeKey *string `json:"customize_key,omitempty"`
}

用户自定义键值对

func (MetaData) String 

func (o MetaData) String() string

type Networks 

type Networks struct {
	// 网络ID。
	Id string `json:"id"`
	// 是否启用IPv6。取值为true时，标识此网卡已启用IPv6。
	Ipv6Enable    *bool          `json:"ipv6_enable,omitempty"`
	Ipv6Bandwidth *Ipv6Bandwidth `json:"ipv6_bandwidth,omitempty"`
}

网络信息

func (Networks) String 

func (o Networks) String() string

type Personality 

type Personality struct {
	// 注入文件路径信息。Linux系统请输入注入文件保存路径，例如 “/etc/foo.txt”。Windows系统注入文件自动保存在C盘根目录，只需要输入保存文件名，例如 “foo”，文件名只能包含字母（a~zA~Z）和数字（0~9）。
	Path string `json:"path"`
	// 注入文件内容。该值应指定为注入文件的内容进行base64格式编码后的信息。
	Content string `json:"content"`
}

注入文件信息。仅支持注入文本文件，最大支持注入5个文件，每个文件最大1KB。

func (Personality) String 

func (o Personality) String() string

type PolicyInstanceQuotas 

type PolicyInstanceQuotas struct {
	// 配额资源详情。
	Resources *[]PolicyInstanceResources `json:"resources,omitempty"`
}

配额列表

func (PolicyInstanceQuotas) String 

func (o PolicyInstanceQuotas) String() string

type PolicyInstanceResources 

type PolicyInstanceResources struct {
	// 查询配额的类型。
	Type *string `json:"type,omitempty"`
	// 已使用的配额数量。
	Used *int32 `json:"used,omitempty"`
	// 配额总数量。
	Quota *int32 `json:"quota,omitempty"`
	// 配额上限。
	Max *int32 `json:"max,omitempty"`
}

配额资源

func (PolicyInstanceResources) String 

func (o PolicyInstanceResources) String() string

type PublicIp 

type PublicIp struct {
	Eip *Eip `json:"eip"`
}

配置云服务器的弹性IP信息

func (PublicIp) String 

func (o PublicIp) String() string

type ResourceTags 

type ResourceTags struct {
	// 资源标签值。最大长度36个unicode字符。
	Key *string `json:"key,omitempty"`
	// 资源标签值。
	Value *string `json:"value,omitempty"`
}

func (ResourceTags) String 

func (o ResourceTags) String() string

type Resources 

type Resources struct {
	// 资源详情ID。
	ResourceId *string `json:"resource_id,omitempty"`
	// 资源详情。
	ResourceDetail *string `json:"resource_detail,omitempty"`
	// 标签列表，没有标签默认为空数组。
	Tags *[]ResourceTags `json:"tags,omitempty"`
	// 资源名称，没有默认为空字符串。
	ResourceName *string `json:"resource_name,omitempty"`
}

func (Resources) String 

func (o Resources) String() string

type ScalingActivityLogList 

type ScalingActivityLogList struct {
	// 伸缩活动状态：SUCCESS：成功。FAIL：失败。DOING：伸缩过程中。
	Status *ScalingActivityLogListStatus `json:"status,omitempty"`
	// 伸缩活动触发时间，遵循UTC时间。
	StartTime *sdktime.SdkTime `json:"start_time,omitempty"`
	// 伸缩活动结束时间，遵循UTC时间。
	EndTime *sdktime.SdkTime `json:"end_time,omitempty"`
	// 伸缩活动日志ID。
	Id *string `json:"id,omitempty"`
	// 完成伸缩活动且只被移出弹性伸缩组的云服务器名称列表，云服务器名之间以逗号分隔。
	InstanceRemovedList *string `json:"instance_removed_list,omitempty"`
	// 完成伸缩活动且被移出弹性伸缩组并删除的云服务器名称列表，云服务器名之间以逗号分隔。
	InstanceDeletedList *string `json:"instance_deleted_list,omitempty"`
	// 完成伸缩活动且被加入弹性伸缩组的云服务器名称列表，云服务器名之间以逗号分割。
	InstanceAddedList *string `json:"instance_added_list,omitempty"`
	// 伸缩活动中变化（增加或减少）的云服务器数量。
	ScalingValue *string `json:"scaling_value,omitempty"`
	// 伸缩活动的描述信息。
	Description *string `json:"description,omitempty"`
	// 伸缩组当前instance值。
	InstanceValue *int32 `json:"instance_value,omitempty"`
	// 伸缩活动最终desire值。
	DesireValue *int32 `json:"desire_value,omitempty"`
}

伸缩活动日志列表。

func (ScalingActivityLogList) String 

func (o ScalingActivityLogList) String() string

type ScalingActivityLogListStatus 

type ScalingActivityLogListStatus struct {
	// contains filtered or unexported fields
}

func (ScalingActivityLogListStatus) MarshalJSON 

func (c ScalingActivityLogListStatus) MarshalJSON() ([]byte, error)

func (*ScalingActivityLogListStatus) UnmarshalJSON 

func (c *ScalingActivityLogListStatus) UnmarshalJSON(b []byte) error

type ScalingActivityLogListStatusEnum 

type ScalingActivityLogListStatusEnum struct {
	SUCCESS ScalingActivityLogListStatus
	FAIL    ScalingActivityLogListStatus
	DING    ScalingActivityLogListStatus
}

func GetScalingActivityLogListStatusEnum 

func GetScalingActivityLogListStatusEnum() ScalingActivityLogListStatusEnum

type ScalingConfiguration 

type ScalingConfiguration struct {
	// 伸缩配置ID，全局唯一。
	ScalingConfigurationId *string `json:"scaling_configuration_id,omitempty"`
	// 租户ID。
	Tenant *string `json:"tenant,omitempty"`
	// 伸缩配置名称。
	ScalingConfigurationName *string               `json:"scaling_configuration_name,omitempty"`
	InstanceConfig           *InstanceConfigResult `json:"instance_config,omitempty"`
	// 创建伸缩配置的时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
}

伸缩配置详情

func (ScalingConfiguration) String 

func (o ScalingConfiguration) String() string

type ScalingGroupInstance 

type ScalingGroupInstance struct {
	// 实例ID。
	InstanceId *string `json:"instance_id,omitempty"`
	// 实例名称。
	InstanceName *string `json:"instance_name,omitempty"`
	// 实例所在伸缩组ID。
	ScalingGroupId *string `json:"scaling_group_id,omitempty"`
	// 实例所在伸缩组名称。
	ScalingGroupName *string `json:"scaling_group_name,omitempty"`
	// 实例在伸缩组中的实力状态周期：INSERVICE： 正在使用。PENDING：正在加入伸缩组。REMOVING：正在移出伸缩组。PENDING_WAIT：正在加入伸缩组：等待。REMOVING_WAIT：正在移出伸缩组：等待。
	LifeCycleState *ScalingGroupInstanceLifeCycleState `json:"life_cycle_state,omitempty"`
	// 实例健康状态:INITAILIZING:初始化；NORMAL：正常；ERROR：错误。
	HealthStatus *ScalingGroupInstanceHealthStatus `json:"health_status,omitempty"`
	// 伸缩配置名称。如果返回为空，表示伸缩配置已经被删除。如果返回MANNUAL_ADD，表示实例为手动加入。
	ScalingConfigurationName *string `json:"scaling_configuration_name,omitempty"`
	// 伸缩配置ID。
	ScalingConfigurationId *string `json:"scaling_configuration_id,omitempty"`
	// 实例加入伸缩组的时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 实例的实例保护属性。
	ProtectFromScalingDown *bool `json:"protect_from_scaling_down,omitempty"`
}

伸缩组实例详情

func (ScalingGroupInstance) String 

func (o ScalingGroupInstance) String() string

type ScalingGroupInstanceHealthStatus 

type ScalingGroupInstanceHealthStatus struct {
	// contains filtered or unexported fields
}

func (ScalingGroupInstanceHealthStatus) MarshalJSON 

func (c ScalingGroupInstanceHealthStatus) MarshalJSON() ([]byte, error)

func (*ScalingGroupInstanceHealthStatus) UnmarshalJSON 

func (c *ScalingGroupInstanceHealthStatus) UnmarshalJSON(b []byte) error

type ScalingGroupInstanceHealthStatusEnum 

type ScalingGroupInstanceHealthStatusEnum struct {
	NORMAL       ScalingGroupInstanceHealthStatus
	ERROR        ScalingGroupInstanceHealthStatus
	INITAILIZING ScalingGroupInstanceHealthStatus
}

func GetScalingGroupInstanceHealthStatusEnum 

func GetScalingGroupInstanceHealthStatusEnum() ScalingGroupInstanceHealthStatusEnum

type ScalingGroupInstanceLifeCycleState 

type ScalingGroupInstanceLifeCycleState struct {
	// contains filtered or unexported fields
}

func (ScalingGroupInstanceLifeCycleState) MarshalJSON 

func (c ScalingGroupInstanceLifeCycleState) MarshalJSON() ([]byte, error)

func (*ScalingGroupInstanceLifeCycleState) UnmarshalJSON 

func (c *ScalingGroupInstanceLifeCycleState) UnmarshalJSON(b []byte) error

type ScalingGroupInstanceLifeCycleStateEnum 

type ScalingGroupInstanceLifeCycleStateEnum struct {
	INSERVICE     ScalingGroupInstanceLifeCycleState
	PENDING       ScalingGroupInstanceLifeCycleState
	REMOVING      ScalingGroupInstanceLifeCycleState
	PENDING_WAIT  ScalingGroupInstanceLifeCycleState
	REMOVING_WAIT ScalingGroupInstanceLifeCycleState
}

func GetScalingGroupInstanceLifeCycleStateEnum 

func GetScalingGroupInstanceLifeCycleStateEnum() ScalingGroupInstanceLifeCycleStateEnum

type ScalingGroups 

type ScalingGroups struct {
	// 伸缩组名称。
	ScalingGroupName *string `json:"scaling_group_name,omitempty"`
	// 伸缩组ID。
	ScalingGroupId *string `json:"scaling_group_id,omitempty"`
	// 伸缩组状态。
	ScalingGroupStatus *ScalingGroupsScalingGroupStatus `json:"scaling_group_status,omitempty"`
	// 伸缩配置ID。
	ScalingConfigurationId *string `json:"scaling_configuration_id,omitempty"`
	// 伸缩配置名称。
	ScalingConfigurationName *string `json:"scaling_configuration_name,omitempty"`
	// 伸缩组中当前实例数。
	CurrentInstanceNumber *int32 `json:"current_instance_number,omitempty"`
	// 伸缩组期望实例数。
	DesireInstanceNumber *int32 `json:"desire_instance_number,omitempty"`
	// 伸缩组最小实例数。
	MinInstanceNumber *int32 `json:"min_instance_number,omitempty"`
	// 伸缩组最大实例数
	MaxInstanceNumber *int32 `json:"max_instance_number,omitempty"`
	// 冷却时间，单位是秒。
	CoolDownTime *int32 `json:"cool_down_time,omitempty"`
	// 经典型负载均衡监听器ID，多个负载均衡监听器ID以逗号分隔。
	LbListenerId *string `json:"lb_listener_id,omitempty"`
	// 增强型负载均衡器信息，该参数为预留字段。
	LbaasListeners *[]LbaasListenersResult `json:"lbaas_listeners,omitempty"`
	// 可用分区信息
	AvailableZones *[]string `json:"available_zones,omitempty"`
	// 网络信息
	Networks *[]Networks `json:"networks,omitempty"`
	// 安全组信息
	SecurityGroups *[]SecurityGroupsResult `json:"security_groups,omitempty"`
	// 创建伸缩组时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 伸缩组所在的VPC ID。
	VpcId *string `json:"vpc_id,omitempty"`
	// 伸缩组详情。
	Detail *string `json:"detail,omitempty"`
	// 伸缩组伸缩标志。
	IsScaling *bool `json:"is_scaling,omitempty"`
	// 健康检查方式。
	HealthPeriodicAuditMethod *ScalingGroupsHealthPeriodicAuditMethod `json:"health_periodic_audit_method,omitempty"`
	// 健康检查的间隔时间。
	HealthPeriodicAuditTime *ScalingGroupsHealthPeriodicAuditTime `json:"health_periodic_audit_time,omitempty"`
	// 健康状况检查宽限期。
	HealthPeriodicAuditGracePeriod *int32 `json:"health_periodic_audit_grace_period,omitempty"`
	// 移除策略。
	InstanceTerminatePolicy *ScalingGroupsInstanceTerminatePolicy `json:"instance_terminate_policy,omitempty"`
	// 通知方式：EMAIL为发送邮件通知。
	Notifications *[]string `json:"notifications,omitempty"`
	// 删除云服务器是否删除云服务器绑定的弹性IP。
	DeletePublicip *bool `json:"delete_publicip,omitempty"`
	// 该参数为预留字段
	CloudLocationId *string `json:"cloud_location_id,omitempty"`
	// 企业项目ID
	EnterpriseProjectId *string `json:"enterprise_project_id,omitempty"`
}

伸缩组详情

func (ScalingGroups) String 

func (o ScalingGroups) String() string

type ScalingGroupsHealthPeriodicAuditMethod 

type ScalingGroupsHealthPeriodicAuditMethod struct {
	// contains filtered or unexported fields
}

func (ScalingGroupsHealthPeriodicAuditMethod) MarshalJSON 

func (c ScalingGroupsHealthPeriodicAuditMethod) MarshalJSON() ([]byte, error)

func (*ScalingGroupsHealthPeriodicAuditMethod) UnmarshalJSON 

func (c *ScalingGroupsHealthPeriodicAuditMethod) UnmarshalJSON(b []byte) error

type ScalingGroupsHealthPeriodicAuditMethodEnum 

type ScalingGroupsHealthPeriodicAuditMethodEnum struct {
	ELB_AUDIT  ScalingGroupsHealthPeriodicAuditMethod
	NOVA_AUDIT ScalingGroupsHealthPeriodicAuditMethod
}

func GetScalingGroupsHealthPeriodicAuditMethodEnum 

func GetScalingGroupsHealthPeriodicAuditMethodEnum() ScalingGroupsHealthPeriodicAuditMethodEnum

type ScalingGroupsHealthPeriodicAuditTime 

type ScalingGroupsHealthPeriodicAuditTime struct {
	// contains filtered or unexported fields
}

func (ScalingGroupsHealthPeriodicAuditTime) MarshalJSON 

func (c ScalingGroupsHealthPeriodicAuditTime) MarshalJSON() ([]byte, error)

func (*ScalingGroupsHealthPeriodicAuditTime) UnmarshalJSON 

func (c *ScalingGroupsHealthPeriodicAuditTime) UnmarshalJSON(b []byte) error

type ScalingGroupsHealthPeriodicAuditTimeEnum 

type ScalingGroupsHealthPeriodicAuditTimeEnum struct {
	E_0   ScalingGroupsHealthPeriodicAuditTime
	E_1   ScalingGroupsHealthPeriodicAuditTime
	E_5   ScalingGroupsHealthPeriodicAuditTime
	E_15  ScalingGroupsHealthPeriodicAuditTime
	E_60  ScalingGroupsHealthPeriodicAuditTime
	E_180 ScalingGroupsHealthPeriodicAuditTime
}

func GetScalingGroupsHealthPeriodicAuditTimeEnum 

func GetScalingGroupsHealthPeriodicAuditTimeEnum() ScalingGroupsHealthPeriodicAuditTimeEnum

type ScalingGroupsInstanceTerminatePolicy 

type ScalingGroupsInstanceTerminatePolicy struct {
	// contains filtered or unexported fields
}

func (ScalingGroupsInstanceTerminatePolicy) MarshalJSON 

func (c ScalingGroupsInstanceTerminatePolicy) MarshalJSON() ([]byte, error)

func (*ScalingGroupsInstanceTerminatePolicy) UnmarshalJSON 

func (c *ScalingGroupsInstanceTerminatePolicy) UnmarshalJSON(b []byte) error

type ScalingGroupsInstanceTerminatePolicyEnum 

type ScalingGroupsInstanceTerminatePolicyEnum struct {
	OLD_CONFIG_OLD_INSTANCE ScalingGroupsInstanceTerminatePolicy
	OLD_CONFIG_NEW_INSTANCE ScalingGroupsInstanceTerminatePolicy
	OLD_INSTANCE            ScalingGroupsInstanceTerminatePolicy
	NEW_INSTANCE            ScalingGroupsInstanceTerminatePolicy
}

func GetScalingGroupsInstanceTerminatePolicyEnum 

func GetScalingGroupsInstanceTerminatePolicyEnum() ScalingGroupsInstanceTerminatePolicyEnum

type ScalingGroupsScalingGroupStatus 

type ScalingGroupsScalingGroupStatus struct {
	// contains filtered or unexported fields
}

func (ScalingGroupsScalingGroupStatus) MarshalJSON 

func (c ScalingGroupsScalingGroupStatus) MarshalJSON() ([]byte, error)

func (*ScalingGroupsScalingGroupStatus) UnmarshalJSON 

func (c *ScalingGroupsScalingGroupStatus) UnmarshalJSON(b []byte) error

type ScalingGroupsScalingGroupStatusEnum 

type ScalingGroupsScalingGroupStatusEnum struct {
	INSERVICE ScalingGroupsScalingGroupStatus
	PAUSED    ScalingGroupsScalingGroupStatus
	ERROR     ScalingGroupsScalingGroupStatus
	DELETING  ScalingGroupsScalingGroupStatus
	FREEZED   ScalingGroupsScalingGroupStatus
}

func GetScalingGroupsScalingGroupStatusEnum 

func GetScalingGroupsScalingGroupStatusEnum() ScalingGroupsScalingGroupStatusEnum

type ScalingPolicyAction 

type ScalingPolicyAction struct {
	// 操作选项。ADD：添加实例。REMOVE/REDUCE：移除实例。SET：设置实例数为
	Operation *ScalingPolicyActionOperation `json:"operation,omitempty"`
	// 操作实例个数，默认为1。配置参数时，instance_number和instance_percentage参数只能选其中一个进行配置。
	InstanceNumber *int32 `json:"instance_number,omitempty"`
	// 操作实例百分比，将当前组容量增加、减少或设置为指定的百分比。当instance_number和instance_percentage参数均无配置时，则操作实例个数为1。配置参数时，instance_number和instance_percentage参数只能选其中一个进行配置。
	InstancePercentage *int32 `json:"instance_percentage,omitempty"`
}

策略执行具体动作

func (ScalingPolicyAction) String 

func (o ScalingPolicyAction) String() string

type ScalingPolicyActionOperation 

type ScalingPolicyActionOperation struct {
	// contains filtered or unexported fields
}

func (ScalingPolicyActionOperation) MarshalJSON 

func (c ScalingPolicyActionOperation) MarshalJSON() ([]byte, error)

func (*ScalingPolicyActionOperation) UnmarshalJSON 

func (c *ScalingPolicyActionOperation) UnmarshalJSON(b []byte) error

type ScalingPolicyActionOperationEnum 

type ScalingPolicyActionOperationEnum struct {
	ADD    ScalingPolicyActionOperation
	REMOVE ScalingPolicyActionOperation
	REDUCE ScalingPolicyActionOperation
	SET    ScalingPolicyActionOperation
}

func GetScalingPolicyActionOperationEnum 

func GetScalingPolicyActionOperationEnum() ScalingPolicyActionOperationEnum

type ScalingPolicyDetail 

type ScalingPolicyDetail struct {
	// 伸缩组ID。
	ScalingGroupId *string `json:"scaling_group_id,omitempty"`
	// 伸缩策略名称。
	ScalingPolicyName *string `json:"scaling_policy_name,omitempty"`
	// 伸缩策略ID。
	ScalingPolicyId *string `json:"scaling_policy_id,omitempty"`
	// 伸缩策略类型：ALARM：告警策略，此时alarm_id有返回，scheduled_policy不会返回。SCHEDULED：定时策略，此时alarm_id不会返回，scheduled_policy有返回，并且recurrence_type、recurrence_value、start_time和end_time不会返回。RECURRENCE：周期策略，此时alarm_id不会返回，scheduled_policy有返回，并且recurrence_type、recurrence_value、start_time和end_time有返回。
	ScalingPolicyType *ScalingPolicyDetailScalingPolicyType `json:"scaling_policy_type,omitempty"`
	// 告警ID，即告警规则的ID，当scaling_policy_type为ALARM时该项必选，此时scheduled_policy不生效。创建告警策略成功后，会自动为该告警ID对应的告警规则的alarm_actions字段增加类型为autoscaling的告警触发动作。告警ID通过查询云监控告警规则列表获取，详见《云监控API参考》的“查询告警规则列表”。
	AlarmId             *string              `json:"alarm_id,omitempty"`
	ScheduledPolicy     *ScheduledPolicy     `json:"scheduled_policy,omitempty"`
	ScalingPolicyAction *ScalingPolicyAction `json:"scaling_policy_action,omitempty"`
	// 冷却时间，取值范围0-86400，默认为300，单位是秒。
	CoolDownTime *int32 `json:"cool_down_time,omitempty"`
	// 创建伸缩策略时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
}

伸缩策略

func (ScalingPolicyDetail) String 

func (o ScalingPolicyDetail) String() string

type ScalingPolicyDetailScalingPolicyType 

type ScalingPolicyDetailScalingPolicyType struct {
	// contains filtered or unexported fields
}

func (ScalingPolicyDetailScalingPolicyType) MarshalJSON 

func (c ScalingPolicyDetailScalingPolicyType) MarshalJSON() ([]byte, error)

func (*ScalingPolicyDetailScalingPolicyType) UnmarshalJSON 

func (c *ScalingPolicyDetailScalingPolicyType) UnmarshalJSON(b []byte) error

type ScalingPolicyDetailScalingPolicyTypeEnum 

type ScalingPolicyDetailScalingPolicyTypeEnum struct {
	ALARM      ScalingPolicyDetailScalingPolicyType
	SCHEDULED  ScalingPolicyDetailScalingPolicyType
	RECURRENCE ScalingPolicyDetailScalingPolicyType
}

func GetScalingPolicyDetailScalingPolicyTypeEnum 

func GetScalingPolicyDetailScalingPolicyTypeEnum() ScalingPolicyDetailScalingPolicyTypeEnum

type ScalingPolicyExecuteLogList 

type ScalingPolicyExecuteLogList struct {
	// 策略执行状态：SUCCESS：成功。FAIL：失败。EXECUTING：执行中
	Status *ScalingPolicyExecuteLogListStatus `json:"status,omitempty"`
	// 策略执行失败原因。
	FailedReason *string `json:"failed_reason,omitempty"`
	// 策略执行类型：SCHEDULE：自动触发（定时）。RECURRENCE：自动触发（周期）。ALARM：自动警告（告警）。MANUAL：手动触发
	ExecuteType *ScalingPolicyExecuteLogListExecuteType `json:"execute_type,omitempty"`
	// 策略执行时间，遵循UTC时间。
	ExecuteTime *sdktime.SdkTime `json:"execute_time,omitempty"`
	// 策略执行日志ID。
	Id *string `json:"id,omitempty"`
	// 租户id。
	ProjectId *string `json:"project_id,omitempty"`
	// 伸缩策略ID。
	ScalingPolicyId *string `json:"scaling_policy_id,omitempty"`
	// 伸缩资源类型：伸缩组：SCALING_GROUP 带宽：BANDWIDTH
	ScalingResourceType *ScalingPolicyExecuteLogListScalingResourceType `json:"scaling_resource_type,omitempty"`
	// 伸缩资源ID。
	ScalingResourceId *string `json:"scaling_resource_id,omitempty"`
	// 伸缩原始值。
	OldValue *string `json:"old_value,omitempty"`
	// 伸缩目标值。
	DesireValue *string `json:"desire_value,omitempty"`
	// 操作限制。当scaling_resource_type为BANDWIDTH时，且operation不为SET时，limit_value生效，单位为Mbit/s。此时，当operation为ADD时，limit_value表示最高带宽限制；当operation为REDUCE时，limit_value表示最低带宽限制。
	LimitValue *int32 `json:"limit_value,omitempty"`
	// 策略执行任务类型。ADD：添加。REMOVE：减少。SET：设置为
	Type *ScalingPolicyExecuteLogListType `json:"type,omitempty"`
	// 策略执行动作包含的具体任务
	JobRecords *[]JobRecords `json:"job_records,omitempty"`
	MetaData   *MetaData     `json:"meta_data,omitempty"`
}

伸缩策略执行日志列表

func (ScalingPolicyExecuteLogList) String 

func (o ScalingPolicyExecuteLogList) String() string

type ScalingPolicyExecuteLogListExecuteType 

type ScalingPolicyExecuteLogListExecuteType struct {
	// contains filtered or unexported fields
}

func (ScalingPolicyExecuteLogListExecuteType) MarshalJSON 

func (c ScalingPolicyExecuteLogListExecuteType) MarshalJSON() ([]byte, error)

func (*ScalingPolicyExecuteLogListExecuteType) UnmarshalJSON 

func (c *ScalingPolicyExecuteLogListExecuteType) UnmarshalJSON(b []byte) error

type ScalingPolicyExecuteLogListExecuteTypeEnum 

type ScalingPolicyExecuteLogListExecuteTypeEnum struct {
	SCHEDULE   ScalingPolicyExecuteLogListExecuteType
	RECURRENCE ScalingPolicyExecuteLogListExecuteType
	ALARM      ScalingPolicyExecuteLogListExecuteType
	MANUAL     ScalingPolicyExecuteLogListExecuteType
}

func GetScalingPolicyExecuteLogListExecuteTypeEnum 

func GetScalingPolicyExecuteLogListExecuteTypeEnum() ScalingPolicyExecuteLogListExecuteTypeEnum

type ScalingPolicyExecuteLogListScalingResourceType 

type ScalingPolicyExecuteLogListScalingResourceType struct {
	// contains filtered or unexported fields
}

func (ScalingPolicyExecuteLogListScalingResourceType) MarshalJSON 

func (c ScalingPolicyExecuteLogListScalingResourceType) MarshalJSON() ([]byte, error)

func (*ScalingPolicyExecuteLogListScalingResourceType) UnmarshalJSON 

func (c *ScalingPolicyExecuteLogListScalingResourceType) UnmarshalJSON(b []byte) error

type ScalingPolicyExecuteLogListScalingResourceTypeEnum 

type ScalingPolicyExecuteLogListScalingResourceTypeEnum struct {
	SCALING_GROUP ScalingPolicyExecuteLogListScalingResourceType
	BANDWIDTH     ScalingPolicyExecuteLogListScalingResourceType
}

func GetScalingPolicyExecuteLogListScalingResourceTypeEnum 

func GetScalingPolicyExecuteLogListScalingResourceTypeEnum() ScalingPolicyExecuteLogListScalingResourceTypeEnum

type ScalingPolicyExecuteLogListStatus 

type ScalingPolicyExecuteLogListStatus struct {
	// contains filtered or unexported fields
}

func (ScalingPolicyExecuteLogListStatus) MarshalJSON 

func (c ScalingPolicyExecuteLogListStatus) MarshalJSON() ([]byte, error)

func (*ScalingPolicyExecuteLogListStatus) UnmarshalJSON 

func (c *ScalingPolicyExecuteLogListStatus) UnmarshalJSON(b []byte) error

type ScalingPolicyExecuteLogListStatusEnum 

type ScalingPolicyExecuteLogListStatusEnum struct {
	SUCCESS   ScalingPolicyExecuteLogListStatus
	FAIL      ScalingPolicyExecuteLogListStatus
	EXECUTING ScalingPolicyExecuteLogListStatus
}

func GetScalingPolicyExecuteLogListStatusEnum 

func GetScalingPolicyExecuteLogListStatusEnum() ScalingPolicyExecuteLogListStatusEnum

type ScalingPolicyExecuteLogListType 

type ScalingPolicyExecuteLogListType struct {
	// contains filtered or unexported fields
}

func (ScalingPolicyExecuteLogListType) MarshalJSON 

func (c ScalingPolicyExecuteLogListType) MarshalJSON() ([]byte, error)

func (*ScalingPolicyExecuteLogListType) UnmarshalJSON 

func (c *ScalingPolicyExecuteLogListType) UnmarshalJSON(b []byte) error

type ScalingPolicyExecuteLogListTypeEnum 

type ScalingPolicyExecuteLogListTypeEnum struct {
	ADD    ScalingPolicyExecuteLogListType
	REMOVE ScalingPolicyExecuteLogListType
	SET    ScalingPolicyExecuteLogListType
}

func GetScalingPolicyExecuteLogListTypeEnum 

func GetScalingPolicyExecuteLogListTypeEnum() ScalingPolicyExecuteLogListTypeEnum

type ScheduledPolicy 

type ScheduledPolicy struct {
	// 触发时间，遵循UTC时间。如果scaling_policy_type为SCHEDULED，则格式为：YYYY-MM-DDThh:mmZ。如果scaling_policy_type为RECURRENCE，则格式为：hh:mm。
	LaunchTime *sdktime.SdkTime `json:"launch_time,omitempty"`
	// 周期触发类型，scaling_policy_type为RECURRENCE时该项必选。Daily：每天执行一次。Weekly：每周指定天执行一次。Monthly：每月指定天执行一次。
	RecurrenceType *ScheduledPolicyRecurrenceType `json:"recurrence_type,omitempty"`
	// 周期触发任务数值，scaling_policy_type为RECURRENCE时该项必选。类型为Daily时，该字段为null，表示每天执行类型为Weekly时，该字段取值范围为1-7，1表示星期日，以此类推，以”,”分割，例如：1,3,5。类型为Monthly时，该字段取值范围为1-31，分别表示每月的日期，以“,”分割，例如：1,10,13,28。
	RecurrenceValue *string `json:"recurrence_value,omitempty"`
	// 周期策略重复执行开始时间，遵循UTC时间。默认为当前时间，格式为：YYYY-MM-DDThh：mZ
	StartTime *sdktime.SdkTime `json:"start_time,omitempty"`
	// 周期策略重复执行结束时间，遵循UTC时间，scaling_policy_type为RECURRENCE时该项必选。当为周期类型策略时，不得早于当前时间和开始时间。格式为：YYYY-MM-DDThh：mmZ
	EndTime *sdktime.SdkTime `json:"end_time,omitempty"`
}

定时、周期任务策略

func (ScheduledPolicy) String 

func (o ScheduledPolicy) String() string

type ScheduledPolicyRecurrenceType 

type ScheduledPolicyRecurrenceType struct {
	// contains filtered or unexported fields
}

func (ScheduledPolicyRecurrenceType) MarshalJSON 

func (c ScheduledPolicyRecurrenceType) MarshalJSON() ([]byte, error)

func (*ScheduledPolicyRecurrenceType) UnmarshalJSON 

func (c *ScheduledPolicyRecurrenceType) UnmarshalJSON(b []byte) error

type ScheduledPolicyRecurrenceTypeEnum 

type ScheduledPolicyRecurrenceTypeEnum struct {
	DAILY   ScheduledPolicyRecurrenceType
	WEEKLY  ScheduledPolicyRecurrenceType
	MONTHLY ScheduledPolicyRecurrenceType
}

func GetScheduledPolicyRecurrenceTypeEnum 

func GetScheduledPolicyRecurrenceTypeEnum() ScheduledPolicyRecurrenceTypeEnum

type SecurityGroups 

type SecurityGroups struct {
	// 安全组ID。
	Id string `json:"id"`
}

安全组信息

func (SecurityGroups) String 

func (o SecurityGroups) String() string

type SecurityGroupsResult 

type SecurityGroupsResult struct {
	// 安全组ID
	Id *string `json:"id,omitempty"`
}

安全组信息

func (SecurityGroupsResult) String 

func (o SecurityGroupsResult) String() string

type ShowLifeCycleHookRequest 

type ShowLifeCycleHookRequest struct {
	ScalingGroupId    string `json:"scaling_group_id"`
	LifecycleHookName string `json:"lifecycle_hook_name"`
}

Request Object

func (ShowLifeCycleHookRequest) String 

func (o ShowLifeCycleHookRequest) String() string

type ShowLifeCycleHookResponse 

type ShowLifeCycleHookResponse struct {
	// 生命周期挂钩名称。
	LifecycleHookName *string `json:"lifecycle_hook_name,omitempty"`
	// 生命周期挂钩类型。INSTANCE_TERMINATING;INSTANCE_LAUNCHING
	LifecycleHookType *ShowLifeCycleHookResponseLifecycleHookType `json:"lifecycle_hook_type,omitempty"`
	// 生命周期挂钩默认回调操作。ABANDON;CONTINUE
	DefaultResult *ShowLifeCycleHookResponseDefaultResult `json:"default_result,omitempty"`
	// 生命周期挂钩超时时间，单位秒。
	DefaultTimeout *int32 `json:"default_timeout,omitempty"`
	// SMN服务中Topic的唯一的资源标识。
	NotificationTopicUrn *string `json:"notification_topic_urn,omitempty"`
	// SMN服务中Topic的资源名称。
	NotificationTopicName *string `json:"notification_topic_name,omitempty"`
	// 自定义通知消息。
	NotificationMetadata *string `json:"notification_metadata,omitempty"`
	// 生命周期挂钩创建时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
}

Response Object

func (ShowLifeCycleHookResponse) String 

func (o ShowLifeCycleHookResponse) String() string

type ShowLifeCycleHookResponseDefaultResult 

type ShowLifeCycleHookResponseDefaultResult struct {
	// contains filtered or unexported fields
}

func (ShowLifeCycleHookResponseDefaultResult) MarshalJSON 

func (c ShowLifeCycleHookResponseDefaultResult) MarshalJSON() ([]byte, error)

func (*ShowLifeCycleHookResponseDefaultResult) UnmarshalJSON 

func (c *ShowLifeCycleHookResponseDefaultResult) UnmarshalJSON(b []byte) error

type ShowLifeCycleHookResponseDefaultResultEnum 

type ShowLifeCycleHookResponseDefaultResultEnum struct {
	ABANDON  ShowLifeCycleHookResponseDefaultResult
	CONTINUE ShowLifeCycleHookResponseDefaultResult
}

func GetShowLifeCycleHookResponseDefaultResultEnum 

func GetShowLifeCycleHookResponseDefaultResultEnum() ShowLifeCycleHookResponseDefaultResultEnum

type ShowLifeCycleHookResponseLifecycleHookType 

type ShowLifeCycleHookResponseLifecycleHookType struct {
	// contains filtered or unexported fields
}

func (ShowLifeCycleHookResponseLifecycleHookType) MarshalJSON 

func (c ShowLifeCycleHookResponseLifecycleHookType) MarshalJSON() ([]byte, error)

func (*ShowLifeCycleHookResponseLifecycleHookType) UnmarshalJSON 

func (c *ShowLifeCycleHookResponseLifecycleHookType) UnmarshalJSON(b []byte) error

type ShowLifeCycleHookResponseLifecycleHookTypeEnum 

type ShowLifeCycleHookResponseLifecycleHookTypeEnum struct {
	INSTANCE_TERMINATING ShowLifeCycleHookResponseLifecycleHookType
	INSTANCE_LAUNCHING   ShowLifeCycleHookResponseLifecycleHookType
}

func GetShowLifeCycleHookResponseLifecycleHookTypeEnum 

func GetShowLifeCycleHookResponseLifecycleHookTypeEnum() ShowLifeCycleHookResponseLifecycleHookTypeEnum

type ShowPolicyAndInstanceQuotaRequest 

type ShowPolicyAndInstanceQuotaRequest struct {
	ScalingGroupId string `json:"scaling_group_id"`
}

Request Object

func (ShowPolicyAndInstanceQuotaRequest) String 

func (o ShowPolicyAndInstanceQuotaRequest) String() string

type ShowPolicyAndInstanceQuotaResponse 

type ShowPolicyAndInstanceQuotaResponse struct {
	AllQuotas *PolicyInstanceQuotas `json:"AllQuotas,omitempty"`
}

Response Object

func (ShowPolicyAndInstanceQuotaResponse) String 

func (o ShowPolicyAndInstanceQuotaResponse) String() string

type ShowResourceQuotaRequest 

type ShowResourceQuotaRequest struct {
}

Request Object

func (ShowResourceQuotaRequest) String 

func (o ShowResourceQuotaRequest) String() string

type ShowResourceQuotaResponse 

type ShowResourceQuotaResponse struct {
	Quotas *AllQuotas `json:"quotas,omitempty"`
}

Response Object

func (ShowResourceQuotaResponse) String 

func (o ShowResourceQuotaResponse) String() string

type ShowScalingConfigRequest 

type ShowScalingConfigRequest struct {
	ScalingConfigurationId string `json:"scaling_configuration_id"`
}

Request Object

func (ShowScalingConfigRequest) String 

func (o ShowScalingConfigRequest) String() string

type ShowScalingConfigResponse 

type ShowScalingConfigResponse struct {
	ScalingConfiguration *ScalingConfiguration `json:"scaling_configuration,omitempty"`
}

Response Object

func (ShowScalingConfigResponse) String 

func (o ShowScalingConfigResponse) String() string

type ShowScalingGroupRequest 

type ShowScalingGroupRequest struct {
	ScalingGroupId string `json:"scaling_group_id"`
}

Request Object

func (ShowScalingGroupRequest) String 

func (o ShowScalingGroupRequest) String() string

type ShowScalingGroupResponse 

type ShowScalingGroupResponse struct {
	ScalingGroup *ScalingGroups `json:"scaling_group,omitempty"`
}

Response Object

func (ShowScalingGroupResponse) String 

func (o ShowScalingGroupResponse) String() string

type ShowScalingPolicyRequest 

type ShowScalingPolicyRequest struct {
	ScalingPolicyId string `json:"scaling_policy_id"`
}

Request Object

func (ShowScalingPolicyRequest) String 

func (o ShowScalingPolicyRequest) String() string

type ShowScalingPolicyResponse 

type ShowScalingPolicyResponse struct {
	ScalingPolicy *ScalingPolicyDetail `json:"scaling_policy,omitempty"`
}

Response Object

func (ShowScalingPolicyResponse) String 

func (o ShowScalingPolicyResponse) String() string

type ShowTagsRequestBody 

type ShowTagsRequestBody struct {
	// 过滤条件，包含标签，最多包含10个Tag，结构体不能缺失。
	Tags *[]TagsMultiValue `json:"tags,omitempty"`
	// 过滤条件，包含任意标签，最多包含10个Tag。
	TagsAny *[]TagsMultiValue `json:"tags_any,omitempty"`
	// 过滤条件，不包含标签，最多包含10个Tag。
	NotTags *[]TagsMultiValue `json:"not_tags,omitempty"`
	// 过滤条件，不包含任意标签，最多包含10个Tag。
	NotTagsAny *[]TagsMultiValue `json:"not_tags_any,omitempty"`
	// 查询记录数（action为count时无此参数）如果action为filter默认为1000，limit最多为1000，不能为负数，最小值为1。
	Limit *string `json:"limit,omitempty"`
	// 分页位置标识（资源ID或索引位置）。
	Marker *string `json:"marker,omitempty"`
	// 操作标识（仅限filter，count）：filter（过滤）：即分页查询。count（查询总条数）：按照条件将总条数返回即可。
	Action ShowTagsRequestBodyAction `json:"action"`
	// （索引位置），从offset指定的下一条数据开始查询。查询第一页数据时，不需要传入此参数。查询后续页码数据时，将查询前一页数据时，不需要传入此参数。查询后续页码数据时，将查询前一页数据时响应体中的值带入此参数。必须为数字，不能为负数。action：count时，无此参数。action：filter时，默认为0
	Offset *string `json:"offset,omitempty"`
	// 模糊搜索字段。
	Matchs *[]Matches `json:"matchs,omitempty"`
}

请求正常

func (ShowTagsRequestBody) String 

func (o ShowTagsRequestBody) String() string

type ShowTagsRequestBodyAction 

type ShowTagsRequestBodyAction struct {
	// contains filtered or unexported fields
}

func (ShowTagsRequestBodyAction) MarshalJSON 

func (c ShowTagsRequestBodyAction) MarshalJSON() ([]byte, error)

func (*ShowTagsRequestBodyAction) UnmarshalJSON 

func (c *ShowTagsRequestBodyAction) UnmarshalJSON(b []byte) error

type ShowTagsRequestBodyActionEnum 

type ShowTagsRequestBodyActionEnum struct {
	FILTER ShowTagsRequestBodyAction
	COUNT  ShowTagsRequestBodyAction
}

func GetShowTagsRequestBodyActionEnum 

func GetShowTagsRequestBodyActionEnum() ShowTagsRequestBodyActionEnum

type TagsMultiValue 

type TagsMultiValue struct {
	// 资源标签键。最大长度127个unicode字符。key不能为空。（搜索时不对此参数做校验）。最多为10个，不能为空或者空字符串。且不能重复。
	Key *string `json:"key,omitempty"`
	// 资源标签值列表。每个值最大长度255个unicode字符，每个key下最多为10个，同一个key中values不能重复。
	Values *[]string `json:"values,omitempty"`
}

func (TagsMultiValue) String 

func (o TagsMultiValue) String() string

type TagsSingleValue 

type TagsSingleValue struct {
	// 资源标签键。最大长度36个Unicode字符，不能为空，不能包含非打印字符ASCII(0-31)，“=”,“*”,“<”,“>”,“\\”,“,”,“|”,“/”。同一资源的key值不能重复。action为delete时，不校验标签字符集，最大长度127个Unicode字符。
	Key *string `json:"key,omitempty"`
	// 资源标签值。每个值最大长度43个Unicode字符，可以为空字符串，不能包含非打印字符ASCII(0-31), “=”,“*”,“<”,“>”,“\\”,“,”,“|”,“/”。action为delete时，不校验标签字符集，每个值最大长度255个Unicode字符。如果value有值按照key/value删除，如果value没值，则按照key删除。
	Value *string `json:"value,omitempty"`
}

资源标签键

func (TagsSingleValue) String 

func (o TagsSingleValue) String() string

type Topics 

type Topics struct {
	// SMN服务中Topic的唯一的资源标识。
	TopicUrn *string `json:"topic_urn,omitempty"`
	// 通知场景，有以下五种类型。SCALING_UP：扩容成功。SCALING_UP_FAIL：扩容失败。SCALING_DOWN：减容成功。SCALING_DOWN_FAIL：减容失败。SCALING_GROUP_ABNORMAL：伸缩组发生异常
	TopicScene *[]string `json:"topic_scene,omitempty"`
	// SMN服务中Topic的资源名称。
	TopicName *string `json:"topic_name,omitempty"`
}

func (Topics) String 

func (o Topics) String() string

type UpdateLifeCycleHookRequest 

type UpdateLifeCycleHookRequest struct {
	ScalingGroupId    string                          `json:"scaling_group_id"`
	LifecycleHookName string                          `json:"lifecycle_hook_name"`
	Body              *UpdateLifeCycleHookRequestBody `json:"body,omitempty"`
}

Request Object

func (UpdateLifeCycleHookRequest) String 

func (o UpdateLifeCycleHookRequest) String() string

type UpdateLifeCycleHookRequestBody 

type UpdateLifeCycleHookRequestBody struct {
	// 生命周期挂钩类型。INSTANCE_TERMINATING。INSTANCE_LAUNCHING。INSTANCE_TERMINATING 类型的挂钩负责在实例终止时将实例挂起，INSTANCE_LAUNCHING 类型的挂钩则是在实例启动时将实例挂起。
	LifecycleHookType *UpdateLifeCycleHookRequestBodyLifecycleHookType `json:"lifecycle_hook_type,omitempty"`
	// 生命周期挂钩默认回调操作。默认情况下，到达超时时间后执行的操作。ABANDON；CONTINUE；如果实例正在启动，则 CONTINUE 表示用户自定义操作已成功，可将实例投入使用。否则，ABANDON 表示用户自定义操作未成功，终止实例，伸缩活动置为失败，重新创建新实例。如果实例正在终止，则 ABANDON 和 CONTINUE 都允许终止实例。不过，ABANDON 将停止其他生命周期挂钩，而 CONTINUE 将允许完成其他生命周期挂钩。该字段缺省时默认为 ABANDON。
	DefaultResult *UpdateLifeCycleHookRequestBodyDefaultResult `json:"default_result,omitempty"`
	// 生命周期挂钩超时时间，取值范围300-86400，默认为3600，单位是秒。默认情况下，实例保持等待状态的时间。您可以延长超时时间，也可以在超时时间结束前进行 CONTINUE 或 ABANDON 操作。
	DefaultTimeout *int32 `json:"default_timeout,omitempty"`
	// SMN 服务中 Topic 的唯一的资源标识。为生命周期挂钩定义一个通知目标，当实例被生命周期挂钩挂起时向该通知目标发送消息。该消息包含实例的基本信息、用户自定义通知消息，以及可用于控制生命周期操作的令牌信息。
	NotificationTopicUrn *string `json:"notification_topic_urn,omitempty"`
	// 自定义通知消息，长度不超过256位，不能包含字符< > & ' ( )当配置了通知目标时，可向其发送用户自定义的通知内容。
	NotificationMetadata *string `json:"notification_metadata,omitempty"`
}

修改生命周期挂钩

func (UpdateLifeCycleHookRequestBody) String 

func (o UpdateLifeCycleHookRequestBody) String() string

type UpdateLifeCycleHookRequestBodyDefaultResult 

type UpdateLifeCycleHookRequestBodyDefaultResult struct {
	// contains filtered or unexported fields
}

func (UpdateLifeCycleHookRequestBodyDefaultResult) MarshalJSON 

func (c UpdateLifeCycleHookRequestBodyDefaultResult) MarshalJSON() ([]byte, error)

func (*UpdateLifeCycleHookRequestBodyDefaultResult) UnmarshalJSON 

func (c *UpdateLifeCycleHookRequestBodyDefaultResult) UnmarshalJSON(b []byte) error

type UpdateLifeCycleHookRequestBodyDefaultResultEnum 

type UpdateLifeCycleHookRequestBodyDefaultResultEnum struct {
	ABANDON  UpdateLifeCycleHookRequestBodyDefaultResult
	CONTINUE UpdateLifeCycleHookRequestBodyDefaultResult
}

func GetUpdateLifeCycleHookRequestBodyDefaultResultEnum 

func GetUpdateLifeCycleHookRequestBodyDefaultResultEnum() UpdateLifeCycleHookRequestBodyDefaultResultEnum

type UpdateLifeCycleHookRequestBodyLifecycleHookType 

type UpdateLifeCycleHookRequestBodyLifecycleHookType struct {
	// contains filtered or unexported fields
}

func (UpdateLifeCycleHookRequestBodyLifecycleHookType) MarshalJSON 

func (c UpdateLifeCycleHookRequestBodyLifecycleHookType) MarshalJSON() ([]byte, error)

func (*UpdateLifeCycleHookRequestBodyLifecycleHookType) UnmarshalJSON 

func (c *UpdateLifeCycleHookRequestBodyLifecycleHookType) UnmarshalJSON(b []byte) error

type UpdateLifeCycleHookRequestBodyLifecycleHookTypeEnum 

type UpdateLifeCycleHookRequestBodyLifecycleHookTypeEnum struct {
	INSTANCE_TERMINATING UpdateLifeCycleHookRequestBodyLifecycleHookType
	INSTANCE_LAUNCHING   UpdateLifeCycleHookRequestBodyLifecycleHookType
}

func GetUpdateLifeCycleHookRequestBodyLifecycleHookTypeEnum 

func GetUpdateLifeCycleHookRequestBodyLifecycleHookTypeEnum() UpdateLifeCycleHookRequestBodyLifecycleHookTypeEnum

type UpdateLifeCycleHookResponse 

type UpdateLifeCycleHookResponse struct {
	// 生命周期挂钩名称。
	LifecycleHookName *string `json:"lifecycle_hook_name,omitempty"`
	// 生命周期挂钩类型。INSTANCE_TERMINATING;INSTANCE_LAUNCHING
	LifecycleHookType *UpdateLifeCycleHookResponseLifecycleHookType `json:"lifecycle_hook_type,omitempty"`
	// 生命周期挂钩默认回调操作。ABANDON;CONTINUE
	DefaultResult *UpdateLifeCycleHookResponseDefaultResult `json:"default_result,omitempty"`
	// 生命周期挂钩超时时间，单位秒。
	DefaultTimeout *int32 `json:"default_timeout,omitempty"`
	// SMN服务中Topic的唯一的资源标识。
	NotificationTopicUrn *string `json:"notification_topic_urn,omitempty"`
	// SMN服务中Topic的资源名称。
	NotificationTopicName *string `json:"notification_topic_name,omitempty"`
	// 自定义通知消息。
	NotificationMetadata *string `json:"notification_metadata,omitempty"`
	// 生命周期挂钩创建时间，遵循UTC时间。
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
}

Response Object

func (UpdateLifeCycleHookResponse) String 

func (o UpdateLifeCycleHookResponse) String() string

type UpdateLifeCycleHookResponseDefaultResult 

type UpdateLifeCycleHookResponseDefaultResult struct {
	// contains filtered or unexported fields
}

func (UpdateLifeCycleHookResponseDefaultResult) MarshalJSON 

func (c UpdateLifeCycleHookResponseDefaultResult) MarshalJSON() ([]byte, error)

func (*UpdateLifeCycleHookResponseDefaultResult) UnmarshalJSON 

func (c *UpdateLifeCycleHookResponseDefaultResult) UnmarshalJSON(b []byte) error

type UpdateLifeCycleHookResponseDefaultResultEnum 

type UpdateLifeCycleHookResponseDefaultResultEnum struct {
	ABANDON  UpdateLifeCycleHookResponseDefaultResult
	CONTINUE UpdateLifeCycleHookResponseDefaultResult
}

func GetUpdateLifeCycleHookResponseDefaultResultEnum 

func GetUpdateLifeCycleHookResponseDefaultResultEnum() UpdateLifeCycleHookResponseDefaultResultEnum

type UpdateLifeCycleHookResponseLifecycleHookType 

type UpdateLifeCycleHookResponseLifecycleHookType struct {
	// contains filtered or unexported fields
}

func (UpdateLifeCycleHookResponseLifecycleHookType) MarshalJSON 

func (c UpdateLifeCycleHookResponseLifecycleHookType) MarshalJSON() ([]byte, error)

func (*UpdateLifeCycleHookResponseLifecycleHookType) UnmarshalJSON 

func (c *UpdateLifeCycleHookResponseLifecycleHookType) UnmarshalJSON(b []byte) error

type UpdateLifeCycleHookResponseLifecycleHookTypeEnum 

type UpdateLifeCycleHookResponseLifecycleHookTypeEnum struct {
	INSTANCE_TERMINATING UpdateLifeCycleHookResponseLifecycleHookType
	INSTANCE_LAUNCHING   UpdateLifeCycleHookResponseLifecycleHookType
}

func GetUpdateLifeCycleHookResponseLifecycleHookTypeEnum 

func GetUpdateLifeCycleHookResponseLifecycleHookTypeEnum() UpdateLifeCycleHookResponseLifecycleHookTypeEnum

type UpdateScalingGroupInstanceRequest 

type UpdateScalingGroupInstanceRequest struct {
	ScalingGroupId string                                 `json:"scaling_group_id"`
	Body           *UpdateScalingGroupInstanceRequestBody `json:"body,omitempty"`
}

Request Object

func (UpdateScalingGroupInstanceRequest) String 

func (o UpdateScalingGroupInstanceRequest) String() string

type UpdateScalingGroupInstanceRequestBody 

type UpdateScalingGroupInstanceRequestBody struct {
	// 云服务器ID。
	InstancesId []string `json:"instances_id"`
	// 从伸缩组中移出实例时，是否删除云服务器。默认为no；可选值为yes或no。只有action为REMOVE时，这个字段才生效。
	InstanceDelete *string `json:"instance_delete,omitempty"`
	// 批量操作实例action标识：添加：ADD  移除： REMOVE  设置实例保护： PROTECT  取消实例保护： UNPROTECT；转入备用状态：ENTER_STANDBY 移出备用状态:EXIT_STANDBY
	Action UpdateScalingGroupInstanceRequestBodyAction `json:"action"`
	// 将实例移入备用状态时，是否补充新的云服务器。取值如下：no：不补充新的实例，默认情况为no。yes：补充新的实例。只有action为ENTER_STANDBY时，这个字段才生效。
	InstanceAppend *string `json:"instance_append,omitempty"`
}

批量操作实例

func (UpdateScalingGroupInstanceRequestBody) String 

func (o UpdateScalingGroupInstanceRequestBody) String() string

type UpdateScalingGroupInstanceRequestBodyAction 

type UpdateScalingGroupInstanceRequestBodyAction struct {
	// contains filtered or unexported fields
}

func (UpdateScalingGroupInstanceRequestBodyAction) MarshalJSON 

func (c UpdateScalingGroupInstanceRequestBodyAction) MarshalJSON() ([]byte, error)

func (*UpdateScalingGroupInstanceRequestBodyAction) UnmarshalJSON 

func (c *UpdateScalingGroupInstanceRequestBodyAction) UnmarshalJSON(b []byte) error

type UpdateScalingGroupInstanceRequestBodyActionEnum 

type UpdateScalingGroupInstanceRequestBodyActionEnum struct {
	ADD           UpdateScalingGroupInstanceRequestBodyAction
	REMOVE        UpdateScalingGroupInstanceRequestBodyAction
	PROTECT       UpdateScalingGroupInstanceRequestBodyAction
	UNPROTECT     UpdateScalingGroupInstanceRequestBodyAction
	ENTER_STANDBY UpdateScalingGroupInstanceRequestBodyAction
	EXIT_STANDBY  UpdateScalingGroupInstanceRequestBodyAction
}

func GetUpdateScalingGroupInstanceRequestBodyActionEnum 

func GetUpdateScalingGroupInstanceRequestBodyActionEnum() UpdateScalingGroupInstanceRequestBodyActionEnum

type UpdateScalingGroupInstanceResponse 

type UpdateScalingGroupInstanceResponse struct {
}

Response Object

func (UpdateScalingGroupInstanceResponse) String 

func (o UpdateScalingGroupInstanceResponse) String() string

type UpdateScalingGroupRequest 

type UpdateScalingGroupRequest struct {
	ScalingGroupId string                         `json:"scaling_group_id"`
	Body           *UpdateScalingGroupRequestBody `json:"body,omitempty"`
}

Request Object

func (UpdateScalingGroupRequest) String 

func (o UpdateScalingGroupRequest) String() string

type UpdateScalingGroupRequestBody 

type UpdateScalingGroupRequestBody struct {
	// 伸缩组名称(1-64个字符)，只能包含中文、字母、数字、下划线、中划线。
	ScalingGroupName *string `json:"scaling_group_name,omitempty"`
	// 期望实例数量，默认值为最小实例数。最小实例数<=期望实例数<=最大实例数
	DesireInstanceNumber *int32 `json:"desire_instance_number,omitempty"`
	// 最小实例数量。
	MinInstanceNumber *int32 `json:"min_instance_number,omitempty"`
	// 最大实例数量，大于等于最小实例数。
	MaxInstanceNumber *int32 `json:"max_instance_number,omitempty"`
	// 冷却时间，取值范围0-86400，单位是秒。
	CoolDownTime *int32 `json:"cool_down_time,omitempty"`
	// 可用分区信息。弹性伸缩活动中自动添加的云服务器会被创建在指定的可用区中。如果没有指定可用分区，会由系统自动指定可用分区。详情请参考地区和终端节点。仅当同时满足以下条件时才可以修改：伸缩组中无伸缩活动；实例数为0；伸缩组为非启用状态。
	AvailableZones *[]string `json:"available_zones,omitempty"`
	// 网络信息，最多支持选择5个子网，传入的第一个子网默认作为云服务器的主网卡。使用vpc_id通过查询VPC服务子网列表接口获取，仅当同时满足以下条件时，才可以修改：伸缩组中无伸缩活动；实例数为0；伸缩组为非启用状态。
	Networks *[]Networks `json:"networks,omitempty"`
	// 安全组信息，最多支持选择1个安全组。使用vpc_id通过查询VPC服务安全组列表接口获取，详见《虚拟私有云API参考》的“查询安全组列表”。当伸缩配置和伸缩组同时指定安全组时，将以伸缩配置中的安全组为准；当伸缩配置和伸缩组都没有指定安全组时，将使用默认安全组。为了使用灵活性更高，推荐在伸缩配置中指定安全组。仅当同时满足以下条件时，才可以修改：伸缩组无伸缩活动；实例数为0；伸缩组为非启用状态。
	SecurityGroups *[]SecurityGroups `json:"security_groups,omitempty"`
	// 弹性负载均衡（经典型）监听器ID，最多支持绑定3个负载均衡监听器，多个负载均衡监听器ID以逗号分隔。首先使用vpc_id通过查询ELB服务负载均衡器列表接口获取负载均衡器的ID，详见《弹性负载均衡API参考》的“查询负载均衡器列表”，再使用该ID查询监听器列表获取，详见《弹性负载均衡API参考》的“查询监听器列表”。仅当同时满足以下条件时，才可以修改：伸缩组无伸缩活动；实例数为0；伸缩组为非启用状态。
	LbListenerId *string `json:"lb_listener_id,omitempty"`
	// 弹性负载均衡器（增强型）信息，最多支持绑定3个负载均衡。该字段与lb_listener_id互斥。
	LbaasListeners *[]LbaasListeners `json:"lbaas_listeners,omitempty"`
	// 伸缩组实例健康检查方式：ELB_AUDIT和NOVA_AUDIT。当伸缩组参数中设置负载均衡时，默认为ELB_AUDIT；否则默认为NOVA_AUDIT。ELB_AUDIT表示负载均衡健康检查方式，在有监听器的伸缩组中有效。NOVA_AUDIT表示弹性伸缩自带的健康检查方式。
	HealthPeriodicAuditMethod *UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod `json:"health_periodic_audit_method,omitempty"`
	// 伸缩组实例健康检查周期（分钟）：1、5、15、60、180。若设置为0，可以实现10秒级健康检查。
	HealthPeriodicAuditTime *UpdateScalingGroupRequestBodyHealthPeriodicAuditTime `json:"health_periodic_audit_time,omitempty"`
	// 伸缩组实例健康状况检查宽限期，取值范围0-86400，单位是秒。当实例加入伸缩组并且进入已启用状态后，健康状况检查宽限期才会启动，伸缩组会等健康状况检查宽限期结束后才检查实例的运行状况。当伸缩组实例健康检查方式为ELB_AUDIT时，该参数生效，若不设置该参数，默认为10分钟。
	HealthPeriodicAuditGracePeriod *int32 `json:"health_periodic_audit_grace_period,omitempty"`
	// 伸缩组实例移除策略：OLD_CONFIG_OLD_INSTANCE（默认）：从根据“较早创建的配置”创建的实例中筛选出较早创建的实例被优先移除。OLD_CONFIG_NEW_INSTANCE：从根据“较早创建的配置”创建的实例中筛选出较新创建的实例被优先移除。OLD_INSTANCE：较早创建的实例被优先移除。NEW_INSTANCE：较新创建的实例将被优先移除。
	InstanceTerminatePolicy *UpdateScalingGroupRequestBodyInstanceTerminatePolicy `json:"instance_terminate_policy,omitempty"`
	// 伸缩配置ID，通过查询弹性伸缩配置列表接口获取，详见查询弹性伸缩配置列表
	ScalingConfigurationId *string `json:"scaling_configuration_id,omitempty"`
	// 通知方式：EMAIL为发送邮件通知。该通知方式即将被废除，建议给弹性伸缩组配置通知功能。详见通知。
	Notifications *[]string `json:"notifications,omitempty"`
	// 配置删除云服务器时是否删除云服务器绑定的弹性IP。取值为true或false，默认为false。true：删除云服务器时，会同时删除绑定在云服务器上的弹性IP。当弹性IP的计费方式为包年包月时，不会被删除。false：删除云服务器时，仅解绑定在云服务器上的弹性IP，不删除弹性IP。
	DeletePublicip *bool `json:"delete_publicip,omitempty"`
	// 企业项目ID，用于指定伸缩组归属的企业项目。当伸缩组配置企业项目时，由该伸缩组创建的弹性云服务器将归属于该企业项目。当没有指定企业项目时，将使用企业项目ID为0的默认项目。
	EnterpriseProjectId *string `json:"enterprise_project_id,omitempty"`
}

修改伸缩组详情

func (UpdateScalingGroupRequestBody) String 

func (o UpdateScalingGroupRequestBody) String() string

type UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod 

type UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod struct {
	// contains filtered or unexported fields
}

func (UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod) MarshalJSON 

func (c UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod) MarshalJSON() ([]byte, error)

func (*UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod) UnmarshalJSON 

func (c *UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod) UnmarshalJSON(b []byte) error

type UpdateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum 

type UpdateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum struct {
	ELB_AUDIT  UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod
	NOVA_AUDIT UpdateScalingGroupRequestBodyHealthPeriodicAuditMethod
}

func GetUpdateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum 

func GetUpdateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum() UpdateScalingGroupRequestBodyHealthPeriodicAuditMethodEnum

type UpdateScalingGroupRequestBodyHealthPeriodicAuditTime 

type UpdateScalingGroupRequestBodyHealthPeriodicAuditTime struct {
	// contains filtered or unexported fields
}

func (UpdateScalingGroupRequestBodyHealthPeriodicAuditTime) MarshalJSON 

func (c UpdateScalingGroupRequestBodyHealthPeriodicAuditTime) MarshalJSON() ([]byte, error)

func (*UpdateScalingGroupRequestBodyHealthPeriodicAuditTime) UnmarshalJSON 

func (c *UpdateScalingGroupRequestBodyHealthPeriodicAuditTime) UnmarshalJSON(b []byte) error

type UpdateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum 

type UpdateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum struct {
	E_0   UpdateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_1   UpdateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_5   UpdateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_15  UpdateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_60  UpdateScalingGroupRequestBodyHealthPeriodicAuditTime
	E_180 UpdateScalingGroupRequestBodyHealthPeriodicAuditTime
}

func GetUpdateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum 

func GetUpdateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum() UpdateScalingGroupRequestBodyHealthPeriodicAuditTimeEnum

type UpdateScalingGroupRequestBodyInstanceTerminatePolicy 

type UpdateScalingGroupRequestBodyInstanceTerminatePolicy struct {
	// contains filtered or unexported fields
}

func (UpdateScalingGroupRequestBodyInstanceTerminatePolicy) MarshalJSON 

func (c UpdateScalingGroupRequestBodyInstanceTerminatePolicy) MarshalJSON() ([]byte, error)

func (*UpdateScalingGroupRequestBodyInstanceTerminatePolicy) UnmarshalJSON 

func (c *UpdateScalingGroupRequestBodyInstanceTerminatePolicy) UnmarshalJSON(b []byte) error

type UpdateScalingGroupRequestBodyInstanceTerminatePolicyEnum 

type UpdateScalingGroupRequestBodyInstanceTerminatePolicyEnum struct {
	OLD_CONFIG_OLD_INSTANCE UpdateScalingGroupRequestBodyInstanceTerminatePolicy
	OLD_CONFIG_NEW_INSTANCE UpdateScalingGroupRequestBodyInstanceTerminatePolicy
	OLD_INSTANCE            UpdateScalingGroupRequestBodyInstanceTerminatePolicy
	NEW_INSTANCE            UpdateScalingGroupRequestBodyInstanceTerminatePolicy
}

func GetUpdateScalingGroupRequestBodyInstanceTerminatePolicyEnum 

func GetUpdateScalingGroupRequestBodyInstanceTerminatePolicyEnum() UpdateScalingGroupRequestBodyInstanceTerminatePolicyEnum

type UpdateScalingGroupResponse 

type UpdateScalingGroupResponse struct {
	// 伸缩组ID
	ScalingGroupId *string `json:"scaling_group_id,omitempty"`
}

Response Object

func (UpdateScalingGroupResponse) String 

func (o UpdateScalingGroupResponse) String() string

type UpdateScalingPolicyRequest 

type UpdateScalingPolicyRequest struct {
	ScalingPolicyId string                          `json:"scaling_policy_id"`
	Body            *UpdateScalingPolicyRequestBody `json:"body,omitempty"`
}

Request Object

func (UpdateScalingPolicyRequest) String 

func (o UpdateScalingPolicyRequest) String() string

type UpdateScalingPolicyRequestBody 

type UpdateScalingPolicyRequestBody struct {
	// 策略名称(1-64字符)，可以用中文、字母、数字、下划线、中划线的组合。
	ScalingPolicyName *string `json:"scaling_policy_name,omitempty"`
	// 策略类型。告警策略：ALARM（与alarm_id对应）；定时策略：SCHEDULED（与scheduled_policy对应）；周期策略：RECURRENCE（与scheduled_policy对应）
	ScalingPolicyType *UpdateScalingPolicyRequestBodyScalingPolicyType `json:"scaling_policy_type,omitempty"`
	// 告警ID，即告警规则的ID，当scaling_policy_type为ALARM时该项必选，此时scheduled_policy不生效。创建告警策略成功后，会自动为该告警ID对应的告警规则的alarm_actions字段增加类型为autoscaling的告警触发动作。告警ID通过查询云监控告警规则列表获取，详见《云监控API参考》的“查询告警规则列表”。
	AlarmId             *string              `json:"alarm_id,omitempty"`
	ScheduledPolicy     *ScheduledPolicy     `json:"scheduled_policy,omitempty"`
	ScalingPolicyAction *ScalingPolicyAction `json:"scaling_policy_action,omitempty"`
	// 冷却时间，取值范围0-86400，默认为900，单位是秒。
	CoolDownTime *int32 `json:"cool_down_time,omitempty"`
}

修改伸缩策略

func (UpdateScalingPolicyRequestBody) String 

func (o UpdateScalingPolicyRequestBody) String() string

type UpdateScalingPolicyRequestBodyScalingPolicyType 

type UpdateScalingPolicyRequestBodyScalingPolicyType struct {
	// contains filtered or unexported fields
}

func (UpdateScalingPolicyRequestBodyScalingPolicyType) MarshalJSON 

func (c UpdateScalingPolicyRequestBodyScalingPolicyType) MarshalJSON() ([]byte, error)

func (*UpdateScalingPolicyRequestBodyScalingPolicyType) UnmarshalJSON 

func (c *UpdateScalingPolicyRequestBodyScalingPolicyType) UnmarshalJSON(b []byte) error

type UpdateScalingPolicyRequestBodyScalingPolicyTypeEnum 

type UpdateScalingPolicyRequestBodyScalingPolicyTypeEnum struct {
	ALARM      UpdateScalingPolicyRequestBodyScalingPolicyType
	SCHEDULED  UpdateScalingPolicyRequestBodyScalingPolicyType
	RECURRENCE UpdateScalingPolicyRequestBodyScalingPolicyType
}

func GetUpdateScalingPolicyRequestBodyScalingPolicyTypeEnum 

func GetUpdateScalingPolicyRequestBodyScalingPolicyTypeEnum() UpdateScalingPolicyRequestBodyScalingPolicyTypeEnum

type UpdateScalingPolicyResponse 

type UpdateScalingPolicyResponse struct {
	// 伸缩策略ID。
	ScalingPolicyId *string `json:"scaling_policy_id,omitempty"`
}

Response Object

func (UpdateScalingPolicyResponse) String 

func (o UpdateScalingPolicyResponse) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.