kce

Documentation

Index

• Constants
• type Kce
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Kce
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kce
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Kce
  • func (c *Kce) AddClusterEpcInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) AddClusterEpcInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) AddClusterEpcInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) AddClusterInstanceToNodePool(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) AddClusterInstanceToNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) AddClusterInstanceToNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) AddClusterInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) AddClusterInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) AddClusterInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) AddExistedInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) AddExistedInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) AddExistedInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) CreateCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) CreateClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) CreateClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) CreateNodePool(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) CreateNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) CreateNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DeleteCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DeleteClusterInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DeleteClusterInstancesFromNodePool(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DeleteClusterInstancesFromNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DeleteClusterInstancesFromNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DeleteClusterInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DeleteClusterInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DeleteClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DeleteClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DeleteNodePool(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DeleteNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DeleteNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DescribeCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DescribeClusterInstance(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DescribeClusterInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DescribeClusterInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DescribeClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DescribeClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DescribeEpcForCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DescribeEpcForClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DescribeEpcForClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DescribeEpcImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DescribeEpcImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DescribeEpcImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DescribeExistedInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DescribeExistedInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DescribeExistedInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DescribeInstanceImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DescribeInstanceImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DescribeInstanceImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DescribeNodePool(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DescribeNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DescribeNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) DownloadClusterConfig(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) DownloadClusterConfigRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) DownloadClusterConfigWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) ForceRemoveClusterInstance(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) ForceRemoveClusterInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) ForceRemoveClusterInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) ModifyClusterInfo(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) ModifyClusterInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) ModifyClusterInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodePool(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) ModifyNodePoolScaleDownPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodePoolScaleDownPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) ModifyNodePoolScaleDownPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodePoolScaleUpPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodePoolScaleUpPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) ModifyNodePoolScaleUpPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodeTemplate(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) ModifyNodeTemplateRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) ModifyNodeTemplateWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kce) ProtectedFromScaleDown(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kce) ProtectedFromScaleDownRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kce) ProtectedFromScaleDownWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

const (
	ServiceName = "kce"       // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "kce"       // ServiceID is a unique identifer of a specific service.
)

Service information constants

Types

type Kce

type Kce struct {
	*client.Client
}

Kce provides the API operation methods for making requests to kce. See this package's package overview docs for details on the service.

Kce methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Kce

extraNew create int can support ssl or region locate set

func New

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kce

New creates a new instance of the Kce client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Kce client from just a session.
svc := kce.New(mySession)

// Create a Kce client with additional configuration
svc := kce.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Kce

SdkNew create int can support ssl or region locate set

func (*Kce) AddClusterEpcInstances

func (c *Kce) AddClusterEpcInstances(input *map[string]interface{}) (*map[string]interface{}, error)

AddClusterEpcInstances API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation AddClusterEpcInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddClusterEpcInstances

func (*Kce) AddClusterEpcInstancesRequest

func (c *Kce) AddClusterEpcInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddClusterEpcInstancesRequest generates a "ksc/request.Request" representing the client's request for the AddClusterEpcInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddClusterEpcInstances for more information on using the AddClusterEpcInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddClusterEpcInstancesRequest method.
req, resp := client.AddClusterEpcInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddClusterEpcInstances

func (*Kce) AddClusterEpcInstancesWithContext

func (c *Kce) AddClusterEpcInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddClusterEpcInstancesWithContext is the same as AddClusterEpcInstances with the addition of the ability to pass a context and additional request options.

See AddClusterEpcInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) AddClusterInstanceToNodePool

func (c *Kce) AddClusterInstanceToNodePool(input *map[string]interface{}) (*map[string]interface{}, error)

AddClusterInstanceToNodePool API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation AddClusterInstanceToNodePool for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddClusterInstanceToNodePool

func (*Kce) AddClusterInstanceToNodePoolRequest

func (c *Kce) AddClusterInstanceToNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddClusterInstanceToNodePoolRequest generates a "ksc/request.Request" representing the client's request for the AddClusterInstanceToNodePool operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddClusterInstanceToNodePool for more information on using the AddClusterInstanceToNodePool API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddClusterInstanceToNodePoolRequest method.
req, resp := client.AddClusterInstanceToNodePoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddClusterInstanceToNodePool

func (*Kce) AddClusterInstanceToNodePoolWithContext

func (c *Kce) AddClusterInstanceToNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddClusterInstanceToNodePoolWithContext is the same as AddClusterInstanceToNodePool with the addition of the ability to pass a context and additional request options.

See AddClusterInstanceToNodePool for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) AddClusterInstances

func (c *Kce) AddClusterInstances(input *map[string]interface{}) (*map[string]interface{}, error)

AddClusterInstances API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation AddClusterInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddClusterInstances

func (*Kce) AddClusterInstancesRequest

func (c *Kce) AddClusterInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddClusterInstancesRequest generates a "ksc/request.Request" representing the client's request for the AddClusterInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddClusterInstances for more information on using the AddClusterInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddClusterInstancesRequest method.
req, resp := client.AddClusterInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddClusterInstances

func (*Kce) AddClusterInstancesWithContext

func (c *Kce) AddClusterInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddClusterInstancesWithContext is the same as AddClusterInstances with the addition of the ability to pass a context and additional request options.

See AddClusterInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) AddExistedInstances

func (c *Kce) AddExistedInstances(input *map[string]interface{}) (*map[string]interface{}, error)

AddExistedInstances API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation AddExistedInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddExistedInstances

func (*Kce) AddExistedInstancesRequest

func (c *Kce) AddExistedInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddExistedInstancesRequest generates a "ksc/request.Request" representing the client's request for the AddExistedInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddExistedInstances for more information on using the AddExistedInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddExistedInstancesRequest method.
req, resp := client.AddExistedInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/AddExistedInstances

func (*Kce) AddExistedInstancesWithContext

func (c *Kce) AddExistedInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddExistedInstancesWithContext is the same as AddExistedInstances with the addition of the ability to pass a context and additional request options.

See AddExistedInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) CreateCluster

func (c *Kce) CreateCluster(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCluster API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation CreateCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/CreateCluster

func (*Kce) CreateClusterRequest

func (c *Kce) CreateClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateClusterRequest generates a "ksc/request.Request" representing the client's request for the CreateCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateCluster for more information on using the CreateCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateClusterRequest method.
req, resp := client.CreateClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/CreateCluster

func (*Kce) CreateClusterWithContext

func (c *Kce) CreateClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateClusterWithContext is the same as CreateCluster with the addition of the ability to pass a context and additional request options.

See CreateCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) CreateNodePool

func (c *Kce) CreateNodePool(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNodePool API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation CreateNodePool for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/CreateNodePool

func (*Kce) CreateNodePoolRequest

func (c *Kce) CreateNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateNodePoolRequest generates a "ksc/request.Request" representing the client's request for the CreateNodePool operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateNodePool for more information on using the CreateNodePool API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateNodePoolRequest method.
req, resp := client.CreateNodePoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/CreateNodePool

func (*Kce) CreateNodePoolWithContext

func (c *Kce) CreateNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateNodePoolWithContext is the same as CreateNodePool with the addition of the ability to pass a context and additional request options.

See CreateNodePool for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DeleteCluster

func (c *Kce) DeleteCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCluster API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DeleteCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteCluster

func (*Kce) DeleteClusterInstances

func (c *Kce) DeleteClusterInstances(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteClusterInstances API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DeleteClusterInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteClusterInstances

func (*Kce) DeleteClusterInstancesFromNodePool

func (c *Kce) DeleteClusterInstancesFromNodePool(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteClusterInstancesFromNodePool API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DeleteClusterInstancesFromNodePool for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteClusterInstancesFromNodePool

func (*Kce) DeleteClusterInstancesFromNodePoolRequest

func (c *Kce) DeleteClusterInstancesFromNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteClusterInstancesFromNodePoolRequest generates a "ksc/request.Request" representing the client's request for the DeleteClusterInstancesFromNodePool operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteClusterInstancesFromNodePool for more information on using the DeleteClusterInstancesFromNodePool API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteClusterInstancesFromNodePoolRequest method.
req, resp := client.DeleteClusterInstancesFromNodePoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteClusterInstancesFromNodePool

func (*Kce) DeleteClusterInstancesFromNodePoolWithContext

func (c *Kce) DeleteClusterInstancesFromNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteClusterInstancesFromNodePoolWithContext is the same as DeleteClusterInstancesFromNodePool with the addition of the ability to pass a context and additional request options.

See DeleteClusterInstancesFromNodePool for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DeleteClusterInstancesRequest

func (c *Kce) DeleteClusterInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteClusterInstancesRequest generates a "ksc/request.Request" representing the client's request for the DeleteClusterInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteClusterInstances for more information on using the DeleteClusterInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteClusterInstancesRequest method.
req, resp := client.DeleteClusterInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteClusterInstances

func (*Kce) DeleteClusterInstancesWithContext

func (c *Kce) DeleteClusterInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteClusterInstancesWithContext is the same as DeleteClusterInstances with the addition of the ability to pass a context and additional request options.

See DeleteClusterInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DeleteClusterRequest

func (c *Kce) DeleteClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteClusterRequest generates a "ksc/request.Request" representing the client's request for the DeleteCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteCluster for more information on using the DeleteCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteClusterRequest method.
req, resp := client.DeleteClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteCluster

func (*Kce) DeleteClusterWithContext

func (c *Kce) DeleteClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteClusterWithContext is the same as DeleteCluster with the addition of the ability to pass a context and additional request options.

See DeleteCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DeleteNodePool

func (c *Kce) DeleteNodePool(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNodePool API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DeleteNodePool for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteNodePool

func (*Kce) DeleteNodePoolRequest

func (c *Kce) DeleteNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteNodePoolRequest generates a "ksc/request.Request" representing the client's request for the DeleteNodePool operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteNodePool for more information on using the DeleteNodePool API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteNodePoolRequest method.
req, resp := client.DeleteNodePoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DeleteNodePool

func (*Kce) DeleteNodePoolWithContext

func (c *Kce) DeleteNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteNodePoolWithContext is the same as DeleteNodePool with the addition of the ability to pass a context and additional request options.

See DeleteNodePool for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DescribeCluster

func (c *Kce) DescribeCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCluster API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DescribeCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeCluster

func (*Kce) DescribeClusterInstance

func (c *Kce) DescribeClusterInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeClusterInstance API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DescribeClusterInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeClusterInstance

func (*Kce) DescribeClusterInstanceRequest

func (c *Kce) DescribeClusterInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeClusterInstanceRequest generates a "ksc/request.Request" representing the client's request for the DescribeClusterInstance operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeClusterInstance for more information on using the DescribeClusterInstance API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeClusterInstanceRequest method.
req, resp := client.DescribeClusterInstanceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeClusterInstance

func (*Kce) DescribeClusterInstanceWithContext

func (c *Kce) DescribeClusterInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeClusterInstanceWithContext is the same as DescribeClusterInstance with the addition of the ability to pass a context and additional request options.

See DescribeClusterInstance for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DescribeClusterRequest

func (c *Kce) DescribeClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeClusterRequest generates a "ksc/request.Request" representing the client's request for the DescribeCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeCluster for more information on using the DescribeCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeClusterRequest method.
req, resp := client.DescribeClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeCluster

func (*Kce) DescribeClusterWithContext

func (c *Kce) DescribeClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeClusterWithContext is the same as DescribeCluster with the addition of the ability to pass a context and additional request options.

See DescribeCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DescribeEpcForCluster

func (c *Kce) DescribeEpcForCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeEpcForCluster API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DescribeEpcForCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeEpcForCluster

func (*Kce) DescribeEpcForClusterRequest

func (c *Kce) DescribeEpcForClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeEpcForClusterRequest generates a "ksc/request.Request" representing the client's request for the DescribeEpcForCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeEpcForCluster for more information on using the DescribeEpcForCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeEpcForClusterRequest method.
req, resp := client.DescribeEpcForClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeEpcForCluster

func (*Kce) DescribeEpcForClusterWithContext

func (c *Kce) DescribeEpcForClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeEpcForClusterWithContext is the same as DescribeEpcForCluster with the addition of the ability to pass a context and additional request options.

See DescribeEpcForCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DescribeEpcImage

func (c *Kce) DescribeEpcImage(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeEpcImage API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DescribeEpcImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeEpcImage

func (*Kce) DescribeEpcImageRequest

func (c *Kce) DescribeEpcImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeEpcImageRequest generates a "ksc/request.Request" representing the client's request for the DescribeEpcImage operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeEpcImage for more information on using the DescribeEpcImage API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeEpcImageRequest method.
req, resp := client.DescribeEpcImageRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeEpcImage

func (*Kce) DescribeEpcImageWithContext

func (c *Kce) DescribeEpcImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeEpcImageWithContext is the same as DescribeEpcImage with the addition of the ability to pass a context and additional request options.

See DescribeEpcImage for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DescribeExistedInstances

func (c *Kce) DescribeExistedInstances(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeExistedInstances API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DescribeExistedInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeExistedInstances

func (*Kce) DescribeExistedInstancesRequest

func (c *Kce) DescribeExistedInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeExistedInstancesRequest generates a "ksc/request.Request" representing the client's request for the DescribeExistedInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeExistedInstances for more information on using the DescribeExistedInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeExistedInstancesRequest method.
req, resp := client.DescribeExistedInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeExistedInstances

func (*Kce) DescribeExistedInstancesWithContext

func (c *Kce) DescribeExistedInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeExistedInstancesWithContext is the same as DescribeExistedInstances with the addition of the ability to pass a context and additional request options.

See DescribeExistedInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DescribeInstanceImage

func (c *Kce) DescribeInstanceImage(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceImage API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DescribeInstanceImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeInstanceImage

func (*Kce) DescribeInstanceImageRequest

func (c *Kce) DescribeInstanceImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeInstanceImageRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstanceImage operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeInstanceImage for more information on using the DescribeInstanceImage API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeInstanceImageRequest method.
req, resp := client.DescribeInstanceImageRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeInstanceImage

func (*Kce) DescribeInstanceImageWithContext

func (c *Kce) DescribeInstanceImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeInstanceImageWithContext is the same as DescribeInstanceImage with the addition of the ability to pass a context and additional request options.

See DescribeInstanceImage for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DescribeNodePool

func (c *Kce) DescribeNodePool(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeNodePool API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DescribeNodePool for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeNodePool

func (*Kce) DescribeNodePoolRequest

func (c *Kce) DescribeNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeNodePoolRequest generates a "ksc/request.Request" representing the client's request for the DescribeNodePool operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeNodePool for more information on using the DescribeNodePool API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeNodePoolRequest method.
req, resp := client.DescribeNodePoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DescribeNodePool

func (*Kce) DescribeNodePoolWithContext

func (c *Kce) DescribeNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeNodePoolWithContext is the same as DescribeNodePool with the addition of the ability to pass a context and additional request options.

See DescribeNodePool for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) DownloadClusterConfig

func (c *Kce) DownloadClusterConfig(input *map[string]interface{}) (*map[string]interface{}, error)

DownloadClusterConfig API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation DownloadClusterConfig for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DownloadClusterConfig

func (*Kce) DownloadClusterConfigRequest

func (c *Kce) DownloadClusterConfigRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DownloadClusterConfigRequest generates a "ksc/request.Request" representing the client's request for the DownloadClusterConfig operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DownloadClusterConfig for more information on using the DownloadClusterConfig API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DownloadClusterConfigRequest method.
req, resp := client.DownloadClusterConfigRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/DownloadClusterConfig

func (*Kce) DownloadClusterConfigWithContext

func (c *Kce) DownloadClusterConfigWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DownloadClusterConfigWithContext is the same as DownloadClusterConfig with the addition of the ability to pass a context and additional request options.

See DownloadClusterConfig for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) ForceRemoveClusterInstance

func (c *Kce) ForceRemoveClusterInstance(input *map[string]interface{}) (*map[string]interface{}, error)

ForceRemoveClusterInstance API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation ForceRemoveClusterInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ForceRemoveClusterInstance

func (*Kce) ForceRemoveClusterInstanceRequest

func (c *Kce) ForceRemoveClusterInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ForceRemoveClusterInstanceRequest generates a "ksc/request.Request" representing the client's request for the ForceRemoveClusterInstance operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ForceRemoveClusterInstance for more information on using the ForceRemoveClusterInstance API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ForceRemoveClusterInstanceRequest method.
req, resp := client.ForceRemoveClusterInstanceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ForceRemoveClusterInstance

func (*Kce) ForceRemoveClusterInstanceWithContext

func (c *Kce) ForceRemoveClusterInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ForceRemoveClusterInstanceWithContext is the same as ForceRemoveClusterInstance with the addition of the ability to pass a context and additional request options.

See ForceRemoveClusterInstance for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) ModifyClusterInfo

func (c *Kce) ModifyClusterInfo(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyClusterInfo API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation ModifyClusterInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyClusterInfo

func (*Kce) ModifyClusterInfoRequest

func (c *Kce) ModifyClusterInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyClusterInfoRequest generates a "ksc/request.Request" representing the client's request for the ModifyClusterInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyClusterInfo for more information on using the ModifyClusterInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyClusterInfoRequest method.
req, resp := client.ModifyClusterInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyClusterInfo

func (*Kce) ModifyClusterInfoWithContext

func (c *Kce) ModifyClusterInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyClusterInfoWithContext is the same as ModifyClusterInfo with the addition of the ability to pass a context and additional request options.

See ModifyClusterInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) ModifyNodePool

func (c *Kce) ModifyNodePool(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNodePool API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation ModifyNodePool for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodePool

func (*Kce) ModifyNodePoolRequest

func (c *Kce) ModifyNodePoolRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyNodePoolRequest generates a "ksc/request.Request" representing the client's request for the ModifyNodePool operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyNodePool for more information on using the ModifyNodePool API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyNodePoolRequest method.
req, resp := client.ModifyNodePoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodePool

func (*Kce) ModifyNodePoolScaleDownPolicy

func (c *Kce) ModifyNodePoolScaleDownPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNodePoolScaleDownPolicy API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation ModifyNodePoolScaleDownPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodePoolScaleDownPolicy

func (*Kce) ModifyNodePoolScaleDownPolicyRequest

func (c *Kce) ModifyNodePoolScaleDownPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyNodePoolScaleDownPolicyRequest generates a "ksc/request.Request" representing the client's request for the ModifyNodePoolScaleDownPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyNodePoolScaleDownPolicy for more information on using the ModifyNodePoolScaleDownPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyNodePoolScaleDownPolicyRequest method.
req, resp := client.ModifyNodePoolScaleDownPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodePoolScaleDownPolicy

func (*Kce) ModifyNodePoolScaleDownPolicyWithContext

func (c *Kce) ModifyNodePoolScaleDownPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyNodePoolScaleDownPolicyWithContext is the same as ModifyNodePoolScaleDownPolicy with the addition of the ability to pass a context and additional request options.

See ModifyNodePoolScaleDownPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) ModifyNodePoolScaleUpPolicy

func (c *Kce) ModifyNodePoolScaleUpPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNodePoolScaleUpPolicy API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation ModifyNodePoolScaleUpPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodePoolScaleUpPolicy

func (*Kce) ModifyNodePoolScaleUpPolicyRequest

func (c *Kce) ModifyNodePoolScaleUpPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyNodePoolScaleUpPolicyRequest generates a "ksc/request.Request" representing the client's request for the ModifyNodePoolScaleUpPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyNodePoolScaleUpPolicy for more information on using the ModifyNodePoolScaleUpPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyNodePoolScaleUpPolicyRequest method.
req, resp := client.ModifyNodePoolScaleUpPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodePoolScaleUpPolicy

func (*Kce) ModifyNodePoolScaleUpPolicyWithContext

func (c *Kce) ModifyNodePoolScaleUpPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyNodePoolScaleUpPolicyWithContext is the same as ModifyNodePoolScaleUpPolicy with the addition of the ability to pass a context and additional request options.

See ModifyNodePoolScaleUpPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) ModifyNodePoolWithContext

func (c *Kce) ModifyNodePoolWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyNodePoolWithContext is the same as ModifyNodePool with the addition of the ability to pass a context and additional request options.

See ModifyNodePool for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) ModifyNodeTemplate

func (c *Kce) ModifyNodeTemplate(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNodeTemplate API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation ModifyNodeTemplate for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodeTemplate

func (*Kce) ModifyNodeTemplateRequest

func (c *Kce) ModifyNodeTemplateRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyNodeTemplateRequest generates a "ksc/request.Request" representing the client's request for the ModifyNodeTemplate operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyNodeTemplate for more information on using the ModifyNodeTemplate API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyNodeTemplateRequest method.
req, resp := client.ModifyNodeTemplateRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ModifyNodeTemplate

func (*Kce) ModifyNodeTemplateWithContext

func (c *Kce) ModifyNodeTemplateWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyNodeTemplateWithContext is the same as ModifyNodeTemplate with the addition of the ability to pass a context and additional request options.

See ModifyNodeTemplate for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kce) ProtectedFromScaleDown

func (c *Kce) ProtectedFromScaleDown(input *map[string]interface{}) (*map[string]interface{}, error)

ProtectedFromScaleDown API operation for kce.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kce's API operation ProtectedFromScaleDown for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ProtectedFromScaleDown

func (*Kce) ProtectedFromScaleDownRequest

func (c *Kce) ProtectedFromScaleDownRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ProtectedFromScaleDownRequest generates a "ksc/request.Request" representing the client's request for the ProtectedFromScaleDown operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ProtectedFromScaleDown for more information on using the ProtectedFromScaleDown API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ProtectedFromScaleDownRequest method.
req, resp := client.ProtectedFromScaleDownRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kce-2019-08-06/ProtectedFromScaleDown

func (*Kce) ProtectedFromScaleDownWithContext

func (c *Kce) ProtectedFromScaleDownWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ProtectedFromScaleDownWithContext is the same as ProtectedFromScaleDown with the addition of the ability to pass a context and additional request options.

See ProtectedFromScaleDown for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.